execute = async (logger, rawData) => {
  const data = rawData;

  const {
    action,
    symbol,
    symbolConfiguration: {
      buy: { lastBuyPriceRemoveThreshold }
    },
    symbolInfo: {
      filterLotSize: { stepSize, minQty },
      filterMinNotional: { minNotional }
    },
    openOrders,
    baseAssetBalance: {
      free: baseAssetFreeBalance,
      locked: baseAssetLockedBalance
    },
    sell: { currentPrice, lastBuyPrice }
  } = data;

  if (['not-determined', 'buy-order-wait'].includes(action) === false) {
    logger.info(
      `Do not process to remove last buy price due to the ${action} action.`
    );
    return data;
  }

  // If last buy price is null, undefined, 0, NaN or less than 0.
  if (!lastBuyPrice || lastBuyPrice <= 0) {
    logger.info('Do not process because last buy price does not exist.');
    return data;
  }

  // If the action is disabled, then do not process.
  const checkDisable = await isActionDisabled(symbol);
  logger.info(
    { tag: 'check-disable', checkDisable },
    'Checked whether symbol is disabled or not.'
  );

  if (checkDisable.isDisabled && checkDisable.canRemoveLastBuyPrice === false) {
    logger.info('Do not remove last buy price because action is disabled.');
    return data;
  }

  // If there is open order for grid trade sell order, then do not process.
  const gridTradeLastSellOrder = await getGridTradeLastOrder(
    logger,
    symbol,
    'sell'
  );
  if (_.isEmpty(gridTradeLastSellOrder) === false) {
    logger.info(
      'Do not process to remove last buy price because there is a grid trade last sell order to be confirmed.'
    );
    return data;
  }

  let processMessage = '';

  if (await isSellOrderCompleted(logger, symbol)) {
    processMessage = 'All sell orders are executed. Delete last buy price.';

    logger.info(processMessage);

    return processRemoveLastBuyPrice(logger, symbol, data, processMessage, {
      lastBuyPrice,
      currentPrice,
      minNotional,
      openOrders
    });
  }

  const lotPrecision = parseFloat(stepSize) === 1 ? 0 : stepSize.indexOf(1) - 1;

  const totalBaseAssetBalance =
    parseFloat(baseAssetFreeBalance) + parseFloat(baseAssetLockedBalance);

  const baseAssetQuantity = parseFloat(
    _.floor(
      totalBaseAssetBalance - totalBaseAssetBalance * (0.1 / 100),
      lotPrecision
    )
  );

  if (isLessThanMinimumQuantity({ baseAssetQuantity, minQty })) {
    processMessage = 'Balance is not enough to sell. Delete last buy price.';

    logger.info(
      { baseAssetQuantity },

      processMessage
    );

    return processRemoveLastBuyPrice(logger, symbol, data, processMessage, {
      lastBuyPrice,
      baseAssetQuantity,
      minQty,
      baseAssetFreeBalance,
      baseAssetLockedBalance,
      totalBaseAssetBalance,
      openOrders
    });
  }

  if (
    isLessThanLastBuyPriceRemoveThreshold({
      baseAssetQuantity,
      currentPrice,
      lastBuyPriceRemoveThreshold
    })
  ) {
    processMessage =
      'Balance is less than the last buy price remove threshold. Delete last buy price.';

    logger.info({ baseAssetQuantity }, processMessage);

    return processRemoveLastBuyPrice(logger, symbol, data, processMessage, {
      lastBuyPrice,
      baseAssetQuantity,
      currentPrice,
      minNotional,
      openOrders
    });
  }

  return data;
}
Remove last buy price if applicable

@param {*} logger
@param {*} rawData