Merge pull request #6692 from eSeR1805/feat_readjust_entry

Feature: Readjust Entry Order

docs/bot-basics.md

@@ -34,6 +34,7 @@ By default, loop runs every few seconds (`internals.process_throttle_secs`) and
 * Check timeouts for open orders.
   * Calls `check_entry_timeout()` strategy callback for open entry orders.
   * Calls `check_exit_timeout()` strategy callback for open exit orders.
+  * Calls `adjust_entry_price()` strategy callback for open entry orders.
 * Verifies existing positions and eventually places exit orders.
   * Considers stoploss, ROI and exit-signal, `custom_exit()` and `custom_stoploss()`.
   * Determine exit-price based on `exit_pricing` configuration setting or by using the `custom_exit_price()` callback.
@@ -58,6 +59,7 @@ This loop will be repeated again and again until the bot is stopped.
 * Calculate entry / exit signals (calls `populate_entry_trend()` and `populate_exit_trend()` once per pair).
 * Loops per candle simulating entry and exit points.
   * Check for Order timeouts, either via the `unfilledtimeout` configuration, or via `check_entry_timeout()` / `check_exit_timeout()` strategy callbacks.
+  * Calls `adjust_entry_price()` strategy callback for open entry orders.
   * Check for trade entry signals (`enter_long` / `enter_short` columns).
   * Confirm trade entry / exits (calls `confirm_trade_entry()` and `confirm_trade_exit()` if implemented in the strategy).
   * Call `custom_entry_price()` (if implemented in the strategy) to determine entry price (Prices are moved to be within the opening candle).

docs/strategy-callbacks.md

@@ -17,6 +17,7 @@ Currently available callbacks:
 * [`confirm_trade_entry()`](#trade-entry-buy-order-confirmation)
 * [`confirm_trade_exit()`](#trade-exit-sell-order-confirmation)
 * [`adjust_trade_position()`](#adjust-trade-position)
+* [`adjust_entry_price()`](#adjust-entry-price)
 * [`leverage()`](#leverage-callback)
 
 !!! Tip "Callback calling sequence"
@@ -713,6 +714,69 @@ class DigDeeperStrategy(IStrategy):
 
 ```
 
+## Adjust Entry Price
+
+The `adjust_entry_price()` callback may be used by strategy developer to refresh/replace limit orders upon arrival of new candles.
+Be aware that `custom_entry_price()` is still the one dictating initial entry limit order price target at the time of entry trigger.
+
+Orders can be cancelled out of this callback by returning `None`.
+
+Returning `current_order_rate` will keep the order on the exchange "as is".
+Returning any other price will cancel the existing order, and replace it with a new order.
+
+The trade open-date (`trade.open_date_utc`) will remain at the time of the very first order placed.
+Please make sure to be aware of this - and eventually adjust your logic in other callbacks to account for this, and use the date of the first filled order instead.
+
+!!! Warning "Regular timeout"
+    Entry `unfilledtimeout` mechanism (as well as `check_entry_timeout()`) takes precedence over this.
+    Entry Orders that are cancelled via the above methods will not have this callback called. Be sure to update timeout values to match your expectations.
+
+```python
+from freqtrade.persistence import Trade
+from datetime import timedelta
+
+class AwesomeStrategy(IStrategy):
+
+    # ... populate_* methods
+
+    def adjust_entry_price(self, trade: Trade, order: Optional[Order], pair: str,
+                           current_time: datetime, proposed_rate: float, current_order_rate: float,
+                           entry_tag: Optional[str], side: str, **kwargs) -> float:
+        """
+        Entry price re-adjustment logic, returning the user desired limit price.
+        This only executes when a order was already placed, still open (unfilled fully or partially)
+        and not timed out on subsequent candles after entry trigger.
+
+        When not implemented by a strategy, returns current_order_rate as default.
+        If current_order_rate is returned then the existing order is maintained.
+        If None is returned then order gets canceled but not replaced by a new one.
+
+        :param pair: Pair that's currently analyzed
+        :param trade: Trade object.
+        :param order: Order object
+        :param current_time: datetime object, containing the current datetime
+        :param proposed_rate: Rate, calculated based on pricing settings in entry_pricing.
+        :param current_order_rate: Rate of the existing order in place.
+        :param entry_tag: Optional entry_tag (buy_tag) if provided with the buy signal.
+        :param side: 'long' or 'short' - indicating the direction of the proposed trade
+        :param **kwargs: Ensure to keep this here so updates to this won't break your strategy.
+        :return float: New entry price value if provided
+
+        """
+        # Limit orders to use and follow SMA200 as price target for the first 10 minutes since entry trigger for BTC/USDT pair.
+        if pair == 'BTC/USDT' and entry_tag == 'long_sma200' and side == 'long' and (current_time - timedelta(minutes=10) > trade.open_date_utc:
+            # just cancel the order if it has been filled more than half of the amount
+            if order.filled > order.remaining:
+                return None
+            else:
+                dataframe, _ = self.dp.get_analyzed_dataframe(pair=pair, timeframe=self.timeframe)
+                current_candle = dataframe.iloc[-1].squeeze()
+                # desired price
+                return current_candle['sma_200']
+        # default: maintain existing order
+        return current_order_rate
+```
+
 ## Leverage Callback
 
 When trading in markets that allow leverage, this method must return the desired Leverage (Defaults to 1 -> No leverage).

freqtrade/constants.py

@@ -483,6 +483,8 @@ CANCEL_REASON = {
     "ALL_CANCELLED": "cancelled (all unfilled and partially filled open orders cancelled)",
     "CANCELLED_ON_EXCHANGE": "cancelled on exchange",
     "FORCE_EXIT": "forcesold",
+    "REPLACE": "cancelled to be replaced by new limit order",
+    "USER_CANCEL": "user requested order cancel"
 }
 
 # List of pairs with their timeframes

freqtrade/freqtradebot.py

@@ -22,6 +22,7 @@ from freqtrade.enums import (ExitCheckTuple, ExitType, RPCMessageType, RunMode,
 from freqtrade.exceptions import (DependencyException, ExchangeError, InsufficientFundsError,
                                   InvalidOrderException, PricingError)
 from freqtrade.exchange import timeframe_to_minutes, timeframe_to_seconds
+from freqtrade.exchange.exchange import timeframe_to_next_date
 from freqtrade.misc import safe_value_fallback, safe_value_fallback2
 from freqtrade.mixins import LoggingMixin
 from freqtrade.persistence import Order, PairLocks, Trade, cleanup_db, init_db
@@ -190,8 +191,8 @@ class FreqtradeBot(LoggingMixin):
         self.strategy.analyze(self.active_pair_whitelist)
 
         with self._exit_lock:
-            # Check and handle any timed out open orders
+            # Check for exchange cancelations, timeouts and user requested replace
-            self.check_handle_timedout()
+            self.manage_open_orders()
 
         # Protect from collisions with force_exit.
         # Without this, freqtrade my try to recreate stoploss_on_exchange orders
@@ -1115,13 +1116,13 @@ class FreqtradeBot(LoggingMixin):
             return True
         return False
 
-    def check_handle_timedout(self) -> None:
+    def manage_open_orders(self) -> None:
         """
-        Check if any orders are timed out and cancel if necessary
+        Management of open orders on exchange. Unfilled orders might be cancelled if timeout
-        :param timeoutvalue: Number of minutes until order is considered timed out
+        was met or replaced if there's a new candle and user has requested it.
+        Timeout setting takes priority over limit order adjustment request.
         :return: None
         """
-
         for trade in Trade.get_open_order_trades():
             try:
                 if not trade.open_order_id:
@@ -1132,33 +1133,87 @@ class FreqtradeBot(LoggingMixin):
                 continue
 
             fully_cancelled = self.update_trade_state(trade, trade.open_order_id, order)
-            is_entering = order['side'] == trade.entry_side
             not_closed = order['status'] == 'open' or fully_cancelled
-            max_timeouts = self.config.get('unfilledtimeout', {}).get('exit_timeout_count', 0)
-
             order_obj = trade.select_order_by_order_id(trade.open_order_id)
 
-            if not_closed and (fully_cancelled or (order_obj and self.strategy.ft_check_timed_out(
+            if not_closed:
-                trade, order_obj, datetime.now(timezone.utc)))
+                if fully_cancelled or (order_obj and self.strategy.ft_check_timed_out(
-            ):
+                   trade, order_obj, datetime.now(timezone.utc))):
-                if is_entering:
+                    self.handle_timedout_order(order, trade)
-                    self.handle_cancel_enter(trade, order, constants.CANCEL_REASON['TIMEOUT'])
                 else:
-                    canceled = self.handle_cancel_exit(
+                    self.replace_order(order, order_obj, trade)
-                        trade, order, constants.CANCEL_REASON['TIMEOUT'])
+
-                    canceled_count = trade.get_exit_order_count()
+    def handle_timedout_order(self, order: Dict, trade: Trade) -> None:
-                    max_timeouts = self.config.get(
+        """
-                        'unfilledtimeout', {}).get('exit_timeout_count', 0)
+        Check if current analyzed order timed out and cancel if necessary.
-                    if canceled and max_timeouts > 0 and canceled_count >= max_timeouts:
+        :param order: Order dict grabbed with exchange.fetch_order()
-                        logger.warning(f'Emergency exiting trade {trade}, as the exit order '
+        :param trade: Trade object.
-                                       f'timed out {max_timeouts} times.')
+        :return: None
-                        try:
+        """
-                            self.execute_trade_exit(
+        if order['side'] == trade.entry_side:
-                                trade, order.get('price'),
+            self.handle_cancel_enter(trade, order, constants.CANCEL_REASON['TIMEOUT'])
-                                exit_check=ExitCheckTuple(exit_type=ExitType.EMERGENCY_EXIT))
+        else:
-                        except DependencyException as exception:
+            canceled = self.handle_cancel_exit(
-                            logger.warning(
+                trade, order, constants.CANCEL_REASON['TIMEOUT'])
-                                f'Unable to emergency sell trade {trade.pair}: {exception}')
+            canceled_count = trade.get_exit_order_count()
+            max_timeouts = self.config.get('unfilledtimeout', {}).get('exit_timeout_count', 0)
+            if canceled and max_timeouts > 0 and canceled_count >= max_timeouts:
+                logger.warning(f'Emergency exiting trade {trade}, as the exit order '
+                               f'timed out {max_timeouts} times.')
+                try:
+                    self.execute_trade_exit(
+                        trade, order['price'],
+                        exit_check=ExitCheckTuple(exit_type=ExitType.EMERGENCY_EXIT))
+                except DependencyException as exception:
+                    logger.warning(
+                        f'Unable to emergency sell trade {trade.pair}: {exception}')
+
+    def replace_order(self, order: Dict, order_obj: Optional[Order], trade: Trade) -> None:
+        """
+        Check if current analyzed entry order should be replaced or simply cancelled.
+        To simply cancel the existing order(no replacement) adjust_entry_price() should return None
+        To maintain existing order adjust_entry_price() should return order_obj.price
+        To replace existing order adjust_entry_price() should return desired price for limit order
+        :param order: Order dict grabbed with exchange.fetch_order()
+        :param order_obj: Order object.
+        :param trade: Trade object.
+        :return: None
+        """
+        analyzed_df, _ = self.dataprovider.get_analyzed_dataframe(trade.pair,
+                                                                  self.strategy.timeframe)
+        latest_candle_open_date = analyzed_df.iloc[-1]['date'] if len(analyzed_df) > 0 else None
+        latest_candle_close_date = timeframe_to_next_date(self.strategy.timeframe,
+                                                          latest_candle_open_date)
+        # Check if new candle
+        if order_obj and latest_candle_close_date > order_obj.order_date_utc:
+            # New candle
+            proposed_rate = self.exchange.get_rate(
+                trade.pair, side='entry', is_short=trade.is_short, refresh=True)
+            adjusted_entry_price = strategy_safe_wrapper(self.strategy.adjust_entry_price,
+                                                         default_retval=order_obj.price)(
+                trade=trade, order=order_obj, pair=trade.pair,
+                current_time=datetime.now(timezone.utc), proposed_rate=proposed_rate,
+                current_order_rate=order_obj.price, entry_tag=trade.enter_tag,
+                side=trade.entry_side)
+
+            full_cancel = False
+            cancel_reason = constants.CANCEL_REASON['REPLACE']
+            if not adjusted_entry_price:
+                full_cancel = True if trade.nr_of_successful_entries == 0 else False
+                cancel_reason = constants.CANCEL_REASON['USER_CANCEL']
+            if order_obj.price != adjusted_entry_price:
+                # cancel existing order if new price is supplied or None
+                self.handle_cancel_enter(trade, order, cancel_reason,
+                                         allow_full_cancel=full_cancel)
+                if adjusted_entry_price:
+                    # place new order only if new price is supplied
+                    self.execute_entry(
+                        pair=trade.pair,
+                        stake_amount=(order_obj.remaining * order_obj.price),
+                        price=adjusted_entry_price,
+                        trade=trade,
+                        is_short=trade.is_short
+                    )
 
     def cancel_all_open_orders(self) -> None:
         """
@@ -1180,7 +1235,10 @@ class FreqtradeBot(LoggingMixin):
                 self.handle_cancel_exit(trade, order, constants.CANCEL_REASON['ALL_CANCELLED'])
         Trade.commit()
 
-    def handle_cancel_enter(self, trade: Trade, order: Dict, reason: str) -> bool:
+    def handle_cancel_enter(
+            self, trade: Trade, order: Dict, reason: str,
+            allow_full_cancel: Optional[bool] = True
+    ) -> bool:
         """
         Buy cancel - cancel order
         :return: True if order was fully cancelled
@@ -1218,9 +1276,10 @@ class FreqtradeBot(LoggingMixin):
         # Using filled to determine the filled amount
         filled_amount = safe_value_fallback2(corder, order, 'filled', 'filled')
         if isclose(filled_amount, 0.0, abs_tol=constants.MATH_CLOSE_PREC):
-            logger.info(f'{side} order fully cancelled. Removing {trade} from database.')
             # if trade is not partially completed and it's the only order, just delete the trade
-            if len(trade.orders) <= 1:
+            open_order_count = len([order for order in trade.orders if order.status == 'open'])
+            if open_order_count <= 1 and allow_full_cancel:
+                logger.info(f'{side} order fully cancelled. Removing {trade} from database.')
                 trade.delete()
                 was_trade_fully_canceled = True
                 reason += f", {constants.CANCEL_REASON['FULLY_CANCELLED']}"

freqtrade/optimize/backtesting.py

@@ -713,19 +713,25 @@ class Backtesting:
 
     def _enter_trade(self, pair: str, row: Tuple, direction: LongShort,
                      stake_amount: Optional[float] = None,
-                     trade: Optional[LocalTrade] = None) -> Optional[LocalTrade]:
+                     trade: Optional[LocalTrade] = None,
+                     requested_rate: Optional[float] = None,
+                     requested_stake: Optional[float] = None) -> Optional[LocalTrade]:
 
         current_time = row[DATE_IDX].to_pydatetime()
         entry_tag = row[ENTER_TAG_IDX] if len(row) >= ENTER_TAG_IDX + 1 else None
         # let's call the custom entry price, using the open price as default price
         order_type = self.strategy.order_types['entry']
-        pos_adjust = trade is not None
+        pos_adjust = trade is not None and requested_rate is None
 
         propose_rate, stake_amount, leverage, min_stake_amount = self.get_valid_price_and_stake(
             pair, row, row[OPEN_IDX], stake_amount, direction, current_time, entry_tag, trade,
             order_type
         )
 
+        # replace proposed rate if another rate was requested
+        propose_rate = requested_rate if requested_rate else propose_rate
+        stake_amount = requested_stake if requested_stake else stake_amount
+
         if not stake_amount:
             # In case of pos adjust, still return the original trade
             # If not pos adjust, trade is None
@@ -807,7 +813,7 @@ class Backtesting:
                 cost=stake_amount + trade.fee_open,
             )
             if pos_adjust and self._get_order_filled(order.price, row):
-                order.close_bt_order(current_time)
+                order.close_bt_order(current_time, trade)
             else:
                 trade.open_order_id = str(self.order_id_counter)
             trade.orders.append(order)
@@ -867,30 +873,78 @@ class Backtesting:
             self.protections.stop_per_pair(pair, current_time, side)
             self.protections.global_stop(current_time, side)
 
-    def check_order_cancel(self, trade: LocalTrade, current_time) -> bool:
+    def manage_open_orders(self, trade: LocalTrade, current_time, row: Tuple) -> bool:
         """
-        Check if an order has been canceled.
+        Check if any open order needs to be cancelled or replaced.
-        Returns True if the trade should be Deleted (initial order was canceled).
+        Returns True if the trade should be deleted.
         """
         for order in [o for o in trade.orders if o.ft_is_open]:
+            if self.check_order_cancel(trade, order, current_time):
+                # delete trade due to order timeout
+                return True
+            elif self.check_order_replace(trade, order, current_time, row):
+                # delete trade due to user request
+                return True
+        # default maintain trade
+        return False
 
-            timedout = self.strategy.ft_check_timed_out(trade, order, current_time)
+    def check_order_cancel(self, trade: LocalTrade, order: Order, current_time) -> bool:
-            if timedout:
+        """
-                if order.side == trade.entry_side:
+        Check if current analyzed order has to be canceled.
-                    self.timedout_entry_orders += 1
+        Returns True if the trade should be Deleted (initial order was canceled).
-                    if trade.nr_of_successful_entries == 0:
+        """
-                        # Remove trade due to entry timeout expiration.
+        timedout = self.strategy.ft_check_timed_out(trade, order, current_time)
-                        return True
+        if timedout:
-                    else:
+            if order.side == trade.entry_side:
-                        # Close additional entry order
+                self.timedout_entry_orders += 1
-                        del trade.orders[trade.orders.index(order)]
+                if trade.nr_of_successful_entries == 0:
-                if order.side == trade.exit_side:
+                    # Remove trade due to entry timeout expiration.
-                    self.timedout_exit_orders += 1
+                    return True
-                    # Close exit order and retry exiting on next signal.
+                else:
+                    # Close additional entry order
                     del trade.orders[trade.orders.index(order)]
+            if order.side == trade.exit_side:
+                self.timedout_exit_orders += 1
+                # Close exit order and retry exiting on next signal.
+                del trade.orders[trade.orders.index(order)]
 
         return False
 
+    def check_order_replace(self, trade: LocalTrade, order: Order, current_time,
+                            row: Tuple) -> bool:
+        """
+        Check if current analyzed entry order has to be replaced and do so.
+        If user requested cancellation and there are no filled orders in the trade will
+        instruct caller to delete the trade.
+        Returns True if the trade should be deleted.
+        """
+        # only check on new candles for open entry orders
+        if order.side == trade.entry_side and current_time > order.order_date_utc:
+            requested_rate = strategy_safe_wrapper(self.strategy.adjust_entry_price,
+                                                   default_retval=order.price)(
+                trade=trade, order=order, pair=trade.pair, current_time=current_time,
+                proposed_rate=row[OPEN_IDX], current_order_rate=order.price,
+                entry_tag=trade.enter_tag, side=trade.trade_direction
+            )  # default value is current order price
+
+            # cancel existing order whenever a new rate is requested (or None)
+            if requested_rate == order.price:
+                # assumption: there can't be multiple open entry orders at any given time
+                return False
+            else:
+                del trade.orders[trade.orders.index(order)]
+
+            # place new order if result was not None
+            if requested_rate:
+                self._enter_trade(pair=trade.pair, row=row, trade=trade,
+                                  requested_rate=requested_rate,
+                                  requested_stake=(order.remaining * order.price),
+                                  direction='short' if trade.is_short else 'long')
+            else:
+                # assumption: there can't be multiple open entry orders at any given time
+                return (trade.nr_of_successful_entries == 0)
+        return False
+
     def validate_row(
             self, data: Dict, pair: str, row_index: int, current_time: datetime) -> Optional[Tuple]:
         try:
@@ -960,9 +1014,9 @@ class Backtesting:
                 self.dataprovider._set_dataframe_max_index(row_index)
 
                 for t in list(open_trades[pair]):
-                    # 1. Cancel expired entry/exit orders.
+                    # 1. Manage currently open orders of active trades
-                    if self.check_order_cancel(t, current_time):
+                    if self.manage_open_orders(t, current_time, row):
-                        # Close trade due to entry timeout expiration.
+                        # Close trade
                         open_trade_count -= 1
                         open_trades[pair].remove(t)
                         self.wallets.update()
@@ -993,7 +1047,7 @@ class Backtesting:
                     # 3. Process entry orders.
                     order = trade.select_order(trade.entry_side, is_open=True)
                     if order and self._get_order_filled(order.price, row):
-                        order.close_bt_order(current_time)
+                        order.close_bt_order(current_time, trade)
                         trade.open_order_id = None
                         LocalTrade.add_bt_trade(trade)
                         self.wallets.update()

freqtrade/persistence/models.py

@@ -219,11 +219,15 @@ class Order(_DECL_BASE):
             'remaining': self.remaining,
         }
 
-    def close_bt_order(self, close_date: datetime):
+    def close_bt_order(self, close_date: datetime, trade: 'LocalTrade'):
         self.order_filled_date = close_date
         self.filled = self.amount
         self.status = 'closed'
         self.ft_is_open = False
+        if (self.ft_order_side == trade.entry_side
+                and len(trade.select_filled_orders(trade.entry_side)) == 1):
+            trade.open_rate = self.price
+            trade.recalc_open_trade_value()
 
     @staticmethod
     def update_orders(orders: List['Order'], order: Dict[str, Any]):

freqtrade/strategy/interface.py

@@ -471,6 +471,34 @@ class IStrategy(ABC, HyperStrategyMixin):
         """
         return None
 
+    def adjust_entry_price(self, trade: Trade, order: Optional[Order], pair: str,
+                           current_time: datetime, proposed_rate: float, current_order_rate: float,
+                           entry_tag: Optional[str], side: str, **kwargs) -> float:
+        """
+        Entry price re-adjustment logic, returning the user desired limit price.
+        This only executes when a order was already placed, still open (unfilled fully or partially)
+        and not timed out on subsequent candles after entry trigger.
+
+        For full documentation please go to https://www.freqtrade.io/en/latest/strategy-callbacks/
+
+        When not implemented by a strategy, returns current_order_rate as default.
+        If current_order_rate is returned then the existing order is maintained.
+        If None is returned then order gets canceled but not replaced by a new one.
+
+        :param pair: Pair that's currently analyzed
+        :param trade: Trade object.
+        :param order: Order object
+        :param current_time: datetime object, containing the current datetime
+        :param proposed_rate: Rate, calculated based on pricing settings in entry_pricing.
+        :param current_order_rate: Rate of the existing order in place.
+        :param entry_tag: Optional entry_tag (buy_tag) if provided with the buy signal.
+        :param side: 'long' or 'short' - indicating the direction of the proposed trade
+        :param **kwargs: Ensure to keep this here so updates to this won't break your strategy.
+        :return float: New entry price value if provided
+
+        """
+        return current_order_rate
+
     def leverage(self, pair: str, current_time: datetime, current_rate: float,
                  proposed_leverage: float, max_leverage: float, side: str,
                  **kwargs) -> float:

freqtrade/templates/base_strategy.py.j2

@@ -4,7 +4,9 @@
 # --- Do not remove these libs ---
 import numpy as np  # noqa
 import pandas as pd  # noqa
-from pandas import DataFrame
+from pandas import DataFrame  # noqa
+from datetime import datetime  # noqa
+from typing import Optional  # noqa
 
 from freqtrade.strategy import (BooleanParameter, CategoricalParameter, DecimalParameter,
                                 IStrategy, IntParameter)

freqtrade/templates/subtemplates/strategy_methods_advanced.j2

@@ -13,7 +13,7 @@ def bot_loop_start(self, **kwargs) -> None:
     pass
 
 def custom_entry_price(self, pair: str, current_time: 'datetime', proposed_rate: float,
-                       entry_tag: 'Optional[str]', **kwargs) -> float:
+                       entry_tag: Optional[str], **kwargs) -> float:
     """
     Custom entry price logic, returning the new entry price.
 
@@ -30,6 +30,34 @@ def custom_entry_price(self, pair: str, current_time: 'datetime', proposed_rate:
     """
     return proposed_rate
 
+def adjust_entry_price(self, trade: 'Trade', order: 'Optional[Order]', pair: str,
+                        current_time: datetime, proposed_rate: float, current_order_rate: float,
+                        entry_tag: Optional[str], side: str, **kwargs) -> float:
+    """
+    Entry price re-adjustment logic, returning the user desired limit price.
+    This only executes when a order was already placed, still open (unfilled fully or partially)
+    and not timed out on subsequent candles after entry trigger.
+
+    For full documentation please go to https://www.freqtrade.io/en/latest/strategy-callbacks/
+
+    When not implemented by a strategy, returns current_order_rate as default.
+    If current_order_rate is returned then the existing order is maintained.
+    If None is returned then order gets canceled but not replaced by a new one.
+
+    :param pair: Pair that's currently analyzed
+    :param trade: Trade object.
+    :param order: Order object
+    :param current_time: datetime object, containing the current datetime
+    :param proposed_rate: Rate, calculated based on pricing settings in entry_pricing.
+    :param current_order_rate: Rate of the existing order in place.
+    :param entry_tag: Optional entry_tag (buy_tag) if provided with the buy signal.
+    :param side: 'long' or 'short' - indicating the direction of the proposed trade
+    :param **kwargs: Ensure to keep this here so updates to this won't break your strategy.
+    :return float: New entry price value if provided
+
+    """
+    return current_order_rate
+
 def custom_exit_price(self, pair: str, trade: 'Trade',
                       current_time: 'datetime', proposed_rate: float,
                       current_profit: float, exit_tag: Optional[str], **kwargs) -> float:
@@ -53,7 +81,7 @@ def custom_exit_price(self, pair: str, trade: 'Trade',
 
 def custom_stake_amount(self, pair: str, current_time: 'datetime', current_rate: float,
                         proposed_stake: float, min_stake: float, max_stake: float,
-                        side: str, entry_tag: 'Optional[str]', **kwargs) -> float:
+                        side: str, entry_tag: Optional[str], **kwargs) -> float:
     """
     Customize stake size for each new trade.
 
@@ -118,7 +146,7 @@ def custom_exit(self, pair: str, trade: 'Trade', current_time: 'datetime', curre
     return None
 
 def confirm_trade_entry(self, pair: str, order_type: str, amount: float, rate: float,
-                        time_in_force: str, current_time: datetime, entry_tag: 'Optional[str]',
+                        time_in_force: str, current_time: datetime, entry_tag: Optional[str],
                         side: str, **kwargs) -> bool:
     """
     Called right before placing a entry order.
@@ -217,7 +245,7 @@ def check_exit_timeout(self, pair: str, trade: 'Trade', order: 'Order',
 
 def adjust_trade_position(self, trade: 'Trade', current_time: 'datetime',
                           current_rate: float, current_profit: float, min_stake: float,
-                          max_stake: float, **kwargs) -> 'Optional[float]':
+                          max_stake: float, **kwargs) -> Optional[float]:
     """
     Custom trade adjustment logic, returning the stake amount that a trade should be increased.
     This means extra buy orders with additional fees.

tests/optimize/__init__.py

@@ -40,6 +40,8 @@ class BTContainer(NamedTuple):
     custom_entry_price: Optional[float] = None
     custom_exit_price: Optional[float] = None
     leverage: float = 1.0
+    timeout: Optional[int] = None
+    adjust_entry_price: Optional[float] = None
 
 
 def _get_frame_time_from_offset(offset):

tests/optimize/test_backtest_detail.py

@@ -754,6 +754,62 @@ tc47 = BTContainer(data=[
     trades=[]
 )
 
+# Test 48: Custom-entry-price below all candles - readjust order
+tc48 = BTContainer(data=[
+    # D   O     H     L     C    V    EL XL ES Xs  BT
+    [0, 5000, 5050, 4950, 5000, 6172, 1, 0],
+    [1, 5000, 5500, 4951, 5000, 6172, 0, 0],  # timeout
+    [2, 4900, 5250, 4500, 5100, 6172, 0, 0],  # Order readjust
+    [3, 5100, 5100, 4650, 4750, 6172, 0, 1],
+    [4, 4750, 4950, 4350, 4750, 6172, 0, 0]],
+    stop_loss=-0.01, roi={"0": 0.10}, profit_perc=-0.087,
+    use_exit_signal=True, timeout=1000,
+    custom_entry_price=4200, adjust_entry_price=5200,
+    trades=[BTrade(exit_reason=ExitType.EXIT_SIGNAL, open_tick=1, close_tick=4, is_short=False)]
+)
+
+
+# Test 49: Custom-entry-price short above all candles - readjust order
+tc49 = BTContainer(data=[
+    # D   O     H     L     C    V    EL XL ES Xs  BT
+    [0, 5000, 5050, 4950, 5000, 6172, 0, 0, 1, 0],
+    [1, 5000, 5200, 4951, 5000, 6172, 0, 0, 0, 0],  # timeout
+    [2, 4900, 5250, 4900, 5100, 6172, 0, 0, 0, 0],  # Order readjust
+    [3, 5100, 5100, 4650, 4750, 6172, 0, 0, 0, 1],
+    [4, 4750, 4950, 4350, 4750, 6172, 0, 0, 0, 0]],
+    stop_loss=-0.01, roi={"0": 0.10}, profit_perc=0.05,
+    use_exit_signal=True, timeout=1000,
+    custom_entry_price=5300, adjust_entry_price=5000,
+    trades=[BTrade(exit_reason=ExitType.EXIT_SIGNAL, open_tick=1, close_tick=4, is_short=True)]
+)
+
+# Test 50: Custom-entry-price below all candles - readjust order cancels order
+tc50 = BTContainer(data=[
+    # D   O     H     L     C    V    EL XL ES Xs  BT
+    [0, 5000, 5050, 4950, 5000, 6172, 1, 0],  # Enter long - place order
+    [1, 5000, 5500, 4951, 5000, 6172, 0, 0],  # Order readjust - cancel order
+    [2, 4900, 5250, 4500, 5100, 6172, 0, 0],
+    [3, 5100, 5100, 4650, 4750, 6172, 0, 0],
+    [4, 4750, 4950, 4350, 4750, 6172, 0, 0]],
+    stop_loss=-0.01, roi={"0": 0.10}, profit_perc=0.0,
+    use_exit_signal=True, timeout=1000,
+    custom_entry_price=4200, adjust_entry_price=None,
+    trades=[]
+)
+
+# Test 51: Custom-entry-price below all candles - readjust order leaves order in place and timeout.
+tc51 = BTContainer(data=[
+    # D   O     H     L     C    V    EL XL ES Xs  BT
+    [0, 5000, 5050, 4950, 5000, 6172, 1, 0],  # Enter long - place order
+    [1, 5000, 5500, 4951, 5000, 6172, 0, 0],  # Order readjust - replace order
+    [2, 4900, 5250, 4500, 5100, 6172, 0, 0],  # Order readjust - maintain order
+    [3, 5100, 5100, 4650, 4750, 6172, 0, 0],  # Timeout
+    [4, 4750, 4950, 4350, 4750, 6172, 0, 0]],
+    stop_loss=-0.01, roi={"0": 0.10}, profit_perc=0.0,
+    use_exit_signal=True, timeout=60,
+    custom_entry_price=4200, adjust_entry_price=4100,
+    trades=[]
+)
 
 TESTS = [
     tc0,
@@ -804,6 +860,10 @@ TESTS = [
     tc45,
     tc46,
     tc47,
+    tc48,
+    tc49,
+    tc50,
+    tc51,
 ]
 
 
@@ -817,6 +877,11 @@ def test_backtest_results(default_conf, fee, mocker, caplog, data: BTContainer)
     default_conf["timeframe"] = tests_timeframe
     default_conf["trailing_stop"] = data.trailing_stop
     default_conf["trailing_only_offset_is_reached"] = data.trailing_only_offset_is_reached
+    if data.timeout:
+        default_conf['unfilledtimeout'].update({
+            'entry': data.timeout,
+            'exit': data.timeout,
+        })
     # Only add this to configuration If it's necessary
     if data.trailing_stop_positive is not None:
         default_conf["trailing_stop_positive"] = data.trailing_stop_positive
@@ -840,6 +905,8 @@ def test_backtest_results(default_conf, fee, mocker, caplog, data: BTContainer)
         backtesting.strategy.custom_entry_price = MagicMock(return_value=data.custom_entry_price)
     if data.custom_exit_price:
         backtesting.strategy.custom_exit_price = MagicMock(return_value=data.custom_exit_price)
+    backtesting.strategy.adjust_entry_price = MagicMock(return_value=data.adjust_entry_price)
+
     backtesting.strategy.use_custom_stoploss = data.use_custom_stoploss
     backtesting.strategy.leverage = lambda **kwargs: data.leverage
     caplog.set_level(logging.DEBUG)

tests/test_freqtradebot.py

@@ -2362,7 +2362,7 @@ def test_bot_loop_start_called_once(mocker, default_conf_usdt, caplog):
 
 
 @pytest.mark.parametrize("is_short", [False, True])
-def test_check_handle_timedout_entry_usercustom(
+def test_manage_open_orders_entry_usercustom(
     default_conf_usdt, ticker_usdt, limit_buy_order_old, open_trade,
     limit_sell_order_old, fee, mocker, is_short
 ) -> None:
@@ -2394,12 +2394,12 @@ def test_check_handle_timedout_entry_usercustom(
     Trade.query.session.add(open_trade)
 
     # Ensure default is to return empty (so not mocked yet)
-    freqtrade.check_handle_timedout()
+    freqtrade.manage_open_orders()
     assert cancel_order_mock.call_count == 0
 
     # Return false - trade remains open
     freqtrade.strategy.check_entry_timeout = MagicMock(return_value=False)
-    freqtrade.check_handle_timedout()
+    freqtrade.manage_open_orders()
     assert cancel_order_mock.call_count == 0
     trades = Trade.query.filter(Trade.open_order_id.is_(open_trade.open_order_id)).all()
     nb_trades = len(trades)
@@ -2407,7 +2407,7 @@ def test_check_handle_timedout_entry_usercustom(
     assert freqtrade.strategy.check_entry_timeout.call_count == 1
     freqtrade.strategy.check_entry_timeout = MagicMock(side_effect=KeyError)
 
-    freqtrade.check_handle_timedout()
+    freqtrade.manage_open_orders()
     assert cancel_order_mock.call_count == 0
     trades = Trade.query.filter(Trade.open_order_id.is_(open_trade.open_order_id)).all()
     nb_trades = len(trades)
@@ -2416,7 +2416,7 @@ def test_check_handle_timedout_entry_usercustom(
     freqtrade.strategy.check_entry_timeout = MagicMock(return_value=True)
 
     # Trade should be closed since the function returns true
-    freqtrade.check_handle_timedout()
+    freqtrade.manage_open_orders()
     assert cancel_order_wr_mock.call_count == 1
     assert rpc_mock.call_count == 1
     trades = Trade.query.filter(Trade.open_order_id.is_(open_trade.open_order_id)).all()
@@ -2426,7 +2426,7 @@ def test_check_handle_timedout_entry_usercustom(
 
 
 @pytest.mark.parametrize("is_short", [False, True])
-def test_check_handle_timedout_entry(
+def test_manage_open_orders_entry(
     default_conf_usdt, ticker_usdt, limit_buy_order_old, open_trade,
     limit_sell_order_old, fee, mocker, is_short
 ) -> None:
@@ -2450,8 +2450,9 @@ def test_check_handle_timedout_entry(
     Trade.query.session.add(open_trade)
 
     freqtrade.strategy.check_entry_timeout = MagicMock(return_value=False)
+    freqtrade.strategy.adjust_entry_price = MagicMock(return_value=1234)
     # check it does cancel buy orders over the time limit
-    freqtrade.check_handle_timedout()
+    freqtrade.manage_open_orders()
     assert cancel_order_mock.call_count == 1
     assert rpc_mock.call_count == 1
     trades = Trade.query.filter(Trade.open_order_id.is_(open_trade.open_order_id)).all()
@@ -2459,6 +2460,99 @@ def test_check_handle_timedout_entry(
     assert nb_trades == 0
     # Custom user buy-timeout is never called
     assert freqtrade.strategy.check_entry_timeout.call_count == 0
+    # Entry adjustment is never called
+    assert freqtrade.strategy.adjust_entry_price.call_count == 0
+
+
+@pytest.mark.parametrize("is_short", [False, True])
+def test_adjust_entry_cancel(
+    default_conf_usdt, ticker_usdt, limit_buy_order_old, open_trade,
+    limit_sell_order_old, fee, mocker, caplog, is_short
+) -> None:
+    freqtrade = get_patched_freqtradebot(mocker, default_conf_usdt)
+    old_order = limit_sell_order_old if is_short else limit_buy_order_old
+    old_order['id'] = open_trade.open_order_id
+    limit_buy_cancel = deepcopy(old_order)
+    limit_buy_cancel['status'] = 'canceled'
+    cancel_order_mock = MagicMock(return_value=limit_buy_cancel)
+    mocker.patch.multiple(
+        'freqtrade.exchange.Exchange',
+        fetch_ticker=ticker_usdt,
+        fetch_order=MagicMock(return_value=old_order),
+        cancel_order_with_result=cancel_order_mock,
+        get_fee=fee
+    )
+
+    open_trade.is_short = is_short
+    Trade.query.session.add(open_trade)
+
+    # Timeout to not interfere
+    freqtrade.strategy.ft_check_timed_out = MagicMock(return_value=False)
+
+    # check that order is cancelled
+    freqtrade.strategy.adjust_entry_price = MagicMock(return_value=None)
+    freqtrade.manage_open_orders()
+    trades = Trade.query.filter(Trade.open_order_id.is_(open_trade.open_order_id)).all()
+    assert len(trades) == 0
+    assert len(Order.query.all()) == 0
+    assert log_has_re(
+        f"{'Sell' if is_short else 'Buy'} order user requested order cancel*", caplog)
+    assert log_has_re(
+        f"{'Sell' if is_short else 'Buy'} order fully cancelled.*", caplog)
+
+    # Entry adjustment is called
+    assert freqtrade.strategy.adjust_entry_price.call_count == 1
+
+
+@pytest.mark.parametrize("is_short", [False, True])
+def test_adjust_entry_maintain_replace(
+    default_conf_usdt, ticker_usdt, limit_buy_order_old, open_trade,
+    limit_sell_order_old, fee, mocker, caplog, is_short
+) -> None:
+    freqtrade = get_patched_freqtradebot(mocker, default_conf_usdt)
+    old_order = limit_sell_order_old if is_short else limit_buy_order_old
+    old_order['id'] = open_trade.open_order_id
+    limit_buy_cancel = deepcopy(old_order)
+    limit_buy_cancel['status'] = 'canceled'
+    cancel_order_mock = MagicMock(return_value=limit_buy_cancel)
+    mocker.patch.multiple(
+        'freqtrade.exchange.Exchange',
+        fetch_ticker=ticker_usdt,
+        fetch_order=MagicMock(return_value=old_order),
+        cancel_order_with_result=cancel_order_mock,
+        get_fee=fee
+    )
+
+    open_trade.is_short = is_short
+    Trade.query.session.add(open_trade)
+
+    # Timeout to not interfere
+    freqtrade.strategy.ft_check_timed_out = MagicMock(return_value=False)
+
+    # Check that order is maintained
+    freqtrade.strategy.adjust_entry_price = MagicMock(return_value=old_order['price'])
+    freqtrade.manage_open_orders()
+    trades = Trade.query.filter(Trade.open_order_id.is_(open_trade.open_order_id)).all()
+    assert len(trades) == 1
+    assert len(Order.get_open_orders()) == 1
+    # Entry adjustment is called
+    assert freqtrade.strategy.adjust_entry_price.call_count == 1
+
+    # Check that order is replaced
+    freqtrade.get_valid_enter_price_and_stake = MagicMock(return_value={100, 10, 1})
+    freqtrade.strategy.adjust_entry_price = MagicMock(return_value=1234)
+    freqtrade.manage_open_orders()
+    trades = Trade.query.filter(Trade.open_order_id.is_(open_trade.open_order_id)).all()
+    assert len(trades) == 1
+    nb_all_orders = len(Order.query.all())
+    assert nb_all_orders == 2
+    # New order seems to be in closed status?
+    # nb_open_orders = len(Order.get_open_orders())
+    # assert nb_open_orders == 1
+    assert log_has_re(
+        f"{'Sell' if is_short else 'Buy'} order cancelled to be replaced*", caplog)
+    # Entry adjustment is called
+    assert freqtrade.strategy.adjust_entry_price.call_count == 1
 
 
 @pytest.mark.parametrize("is_short", [False, True])
@@ -2484,18 +2578,17 @@ def test_check_handle_cancelled_buy(
     Trade.query.session.add(open_trade)
 
     # check it does cancel buy orders over the time limit
-    freqtrade.check_handle_timedout()
+    freqtrade.manage_open_orders()
     assert cancel_order_mock.call_count == 0
     assert rpc_mock.call_count == 1
     trades = Trade.query.filter(Trade.open_order_id.is_(open_trade.open_order_id)).all()
-    nb_trades = len(trades)
+    assert len(trades) == 0
-    assert nb_trades == 0
     assert log_has_re(
         f"{'Sell' if is_short else 'Buy'} order cancelled on exchange for Trade.*", caplog)
 
 
 @pytest.mark.parametrize("is_short", [False, True])
-def test_check_handle_timedout_buy_exception(
+def test_manage_open_orders_buy_exception(
     default_conf_usdt, ticker_usdt, open_trade, is_short, fee, mocker
 ) -> None:
     rpc_mock = patch_RPCManager(mocker)
@@ -2515,7 +2608,7 @@ def test_check_handle_timedout_buy_exception(
     Trade.query.session.add(open_trade)
 
     # check it does cancel buy orders over the time limit
-    freqtrade.check_handle_timedout()
+    freqtrade.manage_open_orders()
     assert cancel_order_mock.call_count == 0
     assert rpc_mock.call_count == 0
     trades = Trade.query.filter(Trade.open_order_id.is_(open_trade.open_order_id)).all()
@@ -2524,7 +2617,7 @@ def test_check_handle_timedout_buy_exception(
 
 
 @pytest.mark.parametrize("is_short", [False, True])
-def test_check_handle_timedout_exit_usercustom(
+def test_manage_open_orders_exit_usercustom(
     default_conf_usdt, ticker_usdt, limit_sell_order_old, mocker,
     is_short, open_trade_usdt, caplog
 ) -> None:
@@ -2553,13 +2646,13 @@ def test_check_handle_timedout_exit_usercustom(
 
     Trade.query.session.add(open_trade_usdt)
     # Ensure default is false
-    freqtrade.check_handle_timedout()
+    freqtrade.manage_open_orders()
     assert cancel_order_mock.call_count == 0
 
     freqtrade.strategy.check_exit_timeout = MagicMock(return_value=False)
     freqtrade.strategy.check_entry_timeout = MagicMock(return_value=False)
     # Return false - No impact
-    freqtrade.check_handle_timedout()
+    freqtrade.manage_open_orders()
     assert cancel_order_mock.call_count == 0
     assert rpc_mock.call_count == 0
     assert open_trade_usdt.is_open is False
@@ -2569,7 +2662,7 @@ def test_check_handle_timedout_exit_usercustom(
     freqtrade.strategy.check_exit_timeout = MagicMock(side_effect=KeyError)
     freqtrade.strategy.check_entry_timeout = MagicMock(side_effect=KeyError)
     # Return Error - No impact
-    freqtrade.check_handle_timedout()
+    freqtrade.manage_open_orders()
     assert cancel_order_mock.call_count == 0
     assert rpc_mock.call_count == 0
     assert open_trade_usdt.is_open is False
@@ -2579,7 +2672,7 @@ def test_check_handle_timedout_exit_usercustom(
     # Return True - sells!
     freqtrade.strategy.check_exit_timeout = MagicMock(return_value=True)
     freqtrade.strategy.check_entry_timeout = MagicMock(return_value=True)
-    freqtrade.check_handle_timedout()
+    freqtrade.manage_open_orders()
     assert cancel_order_mock.call_count == 1
     assert rpc_mock.call_count == 1
     assert open_trade_usdt.is_open is True
@@ -2592,7 +2685,7 @@ def test_check_handle_timedout_exit_usercustom(
     mocker.patch('freqtrade.persistence.Trade.get_exit_order_count', return_value=1)
     mocker.patch('freqtrade.freqtradebot.FreqtradeBot.execute_trade_exit',
                  side_effect=DependencyException)
-    freqtrade.check_handle_timedout()
+    freqtrade.manage_open_orders()
     assert log_has_re('Unable to emergency sell .*', caplog)
 
     et_mock = mocker.patch('freqtrade.freqtradebot.FreqtradeBot.execute_trade_exit')
@@ -2602,16 +2695,16 @@ def test_check_handle_timedout_exit_usercustom(
 
     # If cancelling fails - no emergency sell!
     with patch('freqtrade.freqtradebot.FreqtradeBot.handle_cancel_exit', return_value=False):
-        freqtrade.check_handle_timedout()
+        freqtrade.manage_open_orders()
         assert et_mock.call_count == 0
 
-    freqtrade.check_handle_timedout()
+    freqtrade.manage_open_orders()
     assert log_has_re('Emergency exiting trade.*', caplog)
     assert et_mock.call_count == 1
 
 
 @pytest.mark.parametrize("is_short", [False, True])
-def test_check_handle_timedout_exit(
+def test_manage_open_orders_exit(
     default_conf_usdt, ticker_usdt, limit_sell_order_old, mocker, is_short, open_trade_usdt
 ) -> None:
     rpc_mock = patch_RPCManager(mocker)
@@ -2638,7 +2731,7 @@ def test_check_handle_timedout_exit(
     freqtrade.strategy.check_exit_timeout = MagicMock(return_value=False)
     freqtrade.strategy.check_entry_timeout = MagicMock(return_value=False)
     # check it does cancel sell orders over the time limit
-    freqtrade.check_handle_timedout()
+    freqtrade.manage_open_orders()
     assert cancel_order_mock.call_count == 1
     assert rpc_mock.call_count == 1
     assert open_trade_usdt.is_open is True
@@ -2674,7 +2767,7 @@ def test_check_handle_cancelled_exit(
     Trade.query.session.add(open_trade_usdt)
 
     # check it does cancel sell orders over the time limit
-    freqtrade.check_handle_timedout()
+    freqtrade.manage_open_orders()
     assert cancel_order_mock.call_count == 0
     assert rpc_mock.call_count == 1
     assert open_trade_usdt.is_open is True
@@ -2684,7 +2777,7 @@ def test_check_handle_cancelled_exit(
 
 @pytest.mark.parametrize("is_short", [False, True])
 @pytest.mark.parametrize("leverage", [1, 3, 5, 10])
-def test_check_handle_timedout_partial(
+def test_manage_open_orders_partial(
     default_conf_usdt, ticker_usdt, limit_buy_order_old_partial, is_short, leverage,
     open_trade, mocker
 ) -> None:
@@ -2710,7 +2803,7 @@ def test_check_handle_timedout_partial(
 
     # check it does cancel buy orders over the time limit
     # note this is for a partially-complete buy order
-    freqtrade.check_handle_timedout()
+    freqtrade.manage_open_orders()
     assert cancel_order_mock.call_count == 1
     assert rpc_mock.call_count == 2
     trades = Trade.query.filter(Trade.open_order_id.is_(open_trade.open_order_id)).all()
@@ -2721,7 +2814,7 @@ def test_check_handle_timedout_partial(
 
 
 @pytest.mark.parametrize("is_short", [False, True])
-def test_check_handle_timedout_partial_fee(
+def test_manage_open_orders_partial_fee(
     default_conf_usdt, ticker_usdt, open_trade, caplog, fee, is_short,
     limit_buy_order_old_partial, trades_for_order,
     limit_buy_order_old_partial_canceled, mocker
@@ -2753,7 +2846,7 @@ def test_check_handle_timedout_partial_fee(
     Trade.query.session.add(open_trade)
     # cancelling a half-filled order should update the amount to the bought amount
     # and apply fees if necessary.
-    freqtrade.check_handle_timedout()
+    freqtrade.manage_open_orders()
 
     assert log_has_re(r"Applying fee on amount for Trade.*", caplog)
 
@@ -2770,7 +2863,7 @@ def test_check_handle_timedout_partial_fee(
 
 
 @pytest.mark.parametrize("is_short", [False, True])
-def test_check_handle_timedout_partial_except(
+def test_manage_open_orders_partial_except(
     default_conf_usdt, ticker_usdt, open_trade, caplog, fee, is_short,
     limit_buy_order_old_partial, trades_for_order,
     limit_buy_order_old_partial_canceled, mocker
@@ -2801,7 +2894,7 @@ def test_check_handle_timedout_partial_except(
     Trade.query.session.add(open_trade)
     # cancelling a half-filled order should update the amount to the bought amount
     # and apply fees if necessary.
-    freqtrade.check_handle_timedout()
+    freqtrade.manage_open_orders()
 
     assert log_has_re(r"Could not update trade amount: .*", caplog)
 
@@ -2817,8 +2910,8 @@ def test_check_handle_timedout_partial_except(
     assert trades[0].fee_open == fee()
 
 
-def test_check_handle_timedout_exception(default_conf_usdt, ticker_usdt, open_trade_usdt, mocker,
+def test_manage_open_orders_exception(default_conf_usdt, ticker_usdt, open_trade_usdt, mocker,
-                                         caplog) -> None:
+                                      caplog) -> None:
     patch_RPCManager(mocker)
     patch_exchange(mocker)
     cancel_order_mock = MagicMock()
@@ -2839,7 +2932,7 @@ def test_check_handle_timedout_exception(default_conf_usdt, ticker_usdt, open_tr
     Trade.query.session.add(open_trade_usdt)
 
     caplog.clear()
-    freqtrade.check_handle_timedout()
+    freqtrade.manage_open_orders()
     assert log_has_re(r"Cannot query order for Trade\(id=1, pair=ADA/USDT, amount=30.00000000, "
                       r"is_short=False, leverage=1.0, "
                       r"open_rate=2.00000000, open_since="
@@ -3396,7 +3489,7 @@ def test_execute_trade_exit_with_stoploss_on_exchange(
     assert trade
     trades = [trade]
 
-    freqtrade.check_handle_timedout()
+    freqtrade.manage_open_orders()
     freqtrade.exit_positions(trades)
 
     # Increase the price and sell it
@@ -3448,7 +3541,7 @@ def test_may_execute_trade_exit_after_stoploss_on_exchange_hit(
 
     # Create some test data
     freqtrade.enter_positions()
-    freqtrade.check_handle_timedout()
+    freqtrade.manage_open_orders()
     trade = Trade.query.first()
     trades = [trade]
     assert trade.stoploss_order_id is None
@@ -5214,7 +5307,7 @@ def test_position_adjust(mocker, default_conf_usdt, fee) -> None:
     assert trade.stake_amount == 110
     assert not trade.fee_updated('buy')
 
-    freqtrade.check_handle_timedout()
+    freqtrade.manage_open_orders()
 
     trade = Trade.query.first()
     assert trade
@@ -5320,7 +5413,7 @@ def test_position_adjust(mocker, default_conf_usdt, fee) -> None:
                  MagicMock(return_value=closed_dca_order_1))
     mocker.patch('freqtrade.exchange.Exchange.fetch_order_or_stoploss_order',
                  MagicMock(return_value=closed_dca_order_1))
-    freqtrade.check_handle_timedout()
+    freqtrade.manage_open_orders()
 
     # Assert trade is as expected (averaged dca)
     trade = Trade.query.first()

tests/test_integration.py

@@ -351,3 +351,95 @@ def test_dca_short(default_conf_usdt, ticker_usdt, fee, mocker) -> None:
 
     assert trade.nr_of_successful_entries == 2
     assert trade.nr_of_successful_exits == 1
+
+
+def test_dca_order_adjust(default_conf_usdt, ticker_usdt, fee, mocker) -> None:
+    default_conf_usdt['position_adjustment_enable'] = True
+
+    freqtrade = get_patched_freqtradebot(mocker, default_conf_usdt)
+    mocker.patch.multiple(
+        'freqtrade.exchange.Exchange',
+        fetch_ticker=ticker_usdt,
+        get_fee=fee,
+        amount_to_precision=lambda s, x, y: y,
+        price_to_precision=lambda s, x, y: y,
+    )
+    mocker.patch('freqtrade.exchange.Exchange._is_dry_limit_order_filled', return_value=False)
+
+    patch_get_signal(freqtrade)
+    freqtrade.strategy.custom_entry_price = lambda **kwargs: ticker_usdt['ask'] * 0.96
+
+    freqtrade.enter_positions()
+
+    assert len(Trade.get_trades().all()) == 1
+    trade = Trade.get_trades().first()
+    assert len(trade.orders) == 1
+    assert trade.open_order_id is not None
+    assert pytest.approx(trade.stake_amount) == 60
+    assert trade.open_rate == 1.96
+    # No adjustment
+    freqtrade.process()
+    trade = Trade.get_trades().first()
+    assert len(trade.orders) == 1
+    assert trade.open_order_id is not None
+    assert pytest.approx(trade.stake_amount) == 60
+
+    # Cancel order and place new one
+    freqtrade.strategy.adjust_entry_price = MagicMock(return_value=1.99)
+    freqtrade.process()
+    trade = Trade.get_trades().first()
+    assert len(trade.orders) == 2
+    assert trade.open_order_id is not None
+    # Open rate is not adjusted yet
+    assert trade.open_rate == 1.96
+
+    # Fill order
+    mocker.patch('freqtrade.exchange.Exchange._is_dry_limit_order_filled', return_value=True)
+    freqtrade.process()
+    trade = Trade.get_trades().first()
+    assert len(trade.orders) == 2
+    assert trade.open_order_id is None
+    # Open rate is not adjusted yet
+    assert trade.open_rate == 1.99
+
+    # 2nd order - not filling
+    freqtrade.strategy.adjust_trade_position = MagicMock(return_value=120)
+    mocker.patch('freqtrade.exchange.Exchange._is_dry_limit_order_filled', return_value=False)
+
+    freqtrade.process()
+    trade = Trade.get_trades().first()
+    assert len(trade.orders) == 3
+    assert trade.open_order_id is not None
+    assert trade.open_rate == 1.99
+    assert trade.orders[-1].price == 1.96
+    assert trade.orders[-1].cost == 120
+
+    # Replace new order with diff. order at a lower price
+    freqtrade.strategy.adjust_entry_price = MagicMock(return_value=1.95)
+
+    freqtrade.process()
+    trade = Trade.get_trades().first()
+    assert len(trade.orders) == 4
+    assert trade.open_order_id is not None
+    assert trade.open_rate == 1.99
+    assert trade.orders[-1].price == 1.95
+    assert pytest.approx(trade.orders[-1].cost) == 120
+
+    # Fill DCA order
+    freqtrade.strategy.adjust_trade_position = MagicMock(return_value=None)
+    mocker.patch('freqtrade.exchange.Exchange._is_dry_limit_order_filled', return_value=True)
+    freqtrade.strategy.adjust_entry_price = MagicMock(side_effect=ValueError)
+
+    freqtrade.process()
+    trade = Trade.get_trades().first()
+    assert len(trade.orders) == 4
+    assert trade.open_order_id is None
+    assert pytest.approx(trade.open_rate) == 1.963153456
+    assert trade.orders[-1].price == 1.95
+    assert pytest.approx(trade.orders[-1].cost) == 120
+    assert trade.orders[-1].status == 'closed'
+
+    assert pytest.approx(trade.amount) == 91.689215
+    # Check the 2 filled orders equal the above amount
+    assert pytest.approx(trade.orders[1].amount) == 30.150753768
+    assert pytest.approx(trade.orders[-1].amount) == 61.538461232