async syncTradesForEntries(symbols = []) {
    // fetch all based on our allowed symbol capital
    if (symbols.length === 0) {
      const allSymbols = this.symbols
        .filter(s => s.trade && ((s.trade.capital && s.trade.capital > 0) || (s.trade.currency_capital && s.trade.currency_capital > 0)))
        .map(s => s.symbol);

      // we need position first and randomly add other
      const positionSymbols = _.shuffle((await this.getPositions()).map(p => p.getSymbol()));
      const unknown = _.shuffle(allSymbols).filter(s => !positionSymbols.includes(s));

      positionSymbols.push(...unknown);

      symbols = positionSymbols;
    }

    this.logger.debug(`Binance: Sync trades for entries: ${symbols.length} - ${JSON.stringify(symbols)}`);

    const promises = symbols.map(symbol => async () => {
      let symbolOrders;

      try {
        symbolOrders = await this.client.allOrders({
          symbol: symbol,
          limit: 10
        });
      } catch (e) {
        this.logger.info(`Binance: Sync trades error for entries: ${symbol} - ${String(e)}`);
        return undefined;
      }

      const orders = symbolOrders
        .filter(
          // filled order and fully closed but be have also partially_filled ones if ordering was no fully done
          // in case order was canceled but executedQty is set we have a partially cancel
          order =>
            ['filled', 'partially_filled'].includes(order.status.toLowerCase()) ||
            (order.status.toLowerCase() === 'canceled' && parseFloat(order.executedQty) > 0)
        )
        .sort(
          // order by latest
          (a, b) => b.time - a.time
        )
        .map(order => {
          let price = parseFloat(order.price);

          // market order is not having price info, we need to calulcate it
          if (price === 0 && order.type && order.type.toLowerCase() === 'market') {
            const executedQty = parseFloat(order.executedQty);
            const cummulativeQuoteQty = parseFloat(order.cummulativeQuoteQty);

            if (cummulativeQuoteQty !== 0 && executedQty !== 0) {
              price = cummulativeQuoteQty / executedQty;
            }
          }

          return {
            side: order.side.toLowerCase(),
            price: price,
            symbol: order.symbol,
            time: new Date(order.time),
            size: parseFloat(order.executedQty)
          };
        });

      return { symbol: symbol, orders: orders };
    });

    // no queue for trigger; its timing relevant
    if (promises.length === 1) {
      const result = await promises[0]();
      if (result) {
        this.trades[result.symbol] = result.orders;
      }

      return;
    }

    // add to queue
    promises.forEach(p => {
      this.queue.addQueue3(async () => {
        const result = await p();
        if (result) {
          this.trades[result.symbol] = result.orders;
        }
      });
    });
  }
Binance does not have position trading, but we need entry price so fetch them from filled order history

@param symbols
@returns {Promise<void>}