merge upstream

.github/workflows/ci.yml

@@ -419,7 +419,7 @@ jobs:
 
     - name: Discord notification
       uses: rjstone/discord-webhook-notify@v1
-      if: always() && ( github.event_name != 'pull_request' || github.event.pull_request.head.repo.fork == false)
+      if: always() && ( github.event_name != 'pull_request' || github.event.pull_request.head.repo.fork == false) && (github.event_name != 'schedule')
       with:
           severity: info
           details: Deploy Succeeded!

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/exchanges.md

@@ -228,7 +228,11 @@ OKX requires a passphrase for each api key, you will therefore need to add this
 ```
 
 !!! Warning
-    OKX only provides 100 candles per api call. Therefore, the strategy will only have a pretty low amount of data available in backtesting mode.
+    OKX only provides 300 candles per api call. Therefore, the strategy will only have a pretty low amount of data available in backtesting mode.
+
+!!! Warning "Futures - position mode"
+    OKX Futures has the concept of "position mode" - which can be Net or long/short (hedge mode).
+    Freqtrade supports both modes - but changing the mode mid-trading is not supported and will lead to exceptions and failures to place trades.
 
 ## Gate.io
 

docs/includes/protections.md

@@ -96,6 +96,8 @@ def protections(self):
 `LowProfitPairs` uses all trades for a pair within `lookback_period` in minutes (or in candles when using `lookback_period_candles`) to determine the overall profit ratio.
 If that ratio is below `required_profit`, that pair will be locked for `stop_duration` in minutes (or in candles when using `stop_duration_candles`).
 
+For futures bots, setting `only_per_side` will make the bot only consider one side, and will then only lock this one side, allowing for example shorts to continue after a series of long losses.
+
 The below example will stop trading a pair for 60 minutes if the pair does not have a required profit of 2% (and a minimum of 2 trades) within the last 6 candles.
 
 ``` python
@@ -107,7 +109,8 @@ def protections(self):
             "lookback_period_candles": 6,
             "trade_limit": 2,
             "stop_duration": 60,
-            "required_profit": 0.02
+            "required_profit": 0.02,
+            "only_per_pair": False,
         }
     ]
 ```

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
@@ -494,3 +496,4 @@ TradeList = List[List]
 
 LongShort = Literal['long', 'short']
 EntryExit = Literal['entry', 'exit']
+BuySell = Literal['buy', 'sell']

freqtrade/exchange/exchange.py

@@ -20,7 +20,7 @@ from ccxt.base.decimal_to_precision import (ROUND_DOWN, ROUND_UP, TICK_SIZE, TRU
                                             decimal_to_precision)
 from pandas import DataFrame
 
-from freqtrade.constants import (DEFAULT_AMOUNT_RESERVE_PERCENT, NON_OPEN_EXCHANGE_STATES,
+from freqtrade.constants import (DEFAULT_AMOUNT_RESERVE_PERCENT, NON_OPEN_EXCHANGE_STATES, BuySell,
                                  EntryExit, ListPairsWithTimeframes, PairWithTimeframe)
 from freqtrade.data.converter import ohlcv_to_dataframe, trades_dict_to_list
 from freqtrade.enums import OPTIMIZE_MODES, CandleType, MarginMode, TradingMode
@@ -198,6 +198,7 @@ class Exchange:
 
         if self.trading_mode != TradingMode.SPOT:
             self.fill_leverage_tiers()
+        self.additional_exchange_init()
 
     def __del__(self):
         """
@@ -294,6 +295,14 @@ class Exchange:
         """exchange ccxt precisionMode"""
         return self._api.precisionMode
 
+    def additional_exchange_init(self) -> None:
+        """
+        Additional exchange initialization logic.
+        .api will be available at this point.
+        Must be overridden in child methods if required.
+        """
+        pass
+
     def _log_exchange_response(self, endpoint, response) -> None:
         """ Log exchange responses """
         if self.log_responses:
@@ -937,13 +946,14 @@ class Exchange:
 
     # Order handling
 
-    def _lev_prep(self, pair: str, leverage: float, side: str):
+    def _lev_prep(self, pair: str, leverage: float, side: BuySell):
         if self.trading_mode != TradingMode.SPOT:
             self.set_margin_mode(pair, self.margin_mode)
             self._set_leverage(leverage, pair)
 
     def _get_params(
         self,
+        side: BuySell,
         ordertype: str,
         leverage: float,
         reduceOnly: bool,
@@ -962,7 +972,7 @@ class Exchange:
         *,
         pair: str,
         ordertype: str,
-        side: str,
+        side: BuySell,
         amount: float,
         rate: float,
         leverage: float,
@@ -973,7 +983,7 @@ class Exchange:
             dry_order = self.create_dry_run_order(pair, ordertype, side, amount, rate, leverage)
             return dry_order
 
-        params = self._get_params(ordertype, leverage, reduceOnly, time_in_force)
+        params = self._get_params(side, ordertype, leverage, reduceOnly, time_in_force)
 
         try:
             # Set the precision for amount and price(rate) as accepted by the exchange
@@ -1058,7 +1068,7 @@ class Exchange:
 
     @retrier(retries=0)
     def stoploss(self, pair: str, amount: float, stop_price: float, order_types: Dict,
-                 side: str, leverage: float) -> Dict:
+                 side: BuySell, leverage: float) -> Dict:
         """
         creates a stoploss order.
         requires `_ft_has['stoploss_order_types']` to be set as a dict mapping limit and market

freqtrade/exchange/ftx.py

@@ -4,6 +4,7 @@ from typing import Any, Dict, List, Tuple
 
 import ccxt
 
+from freqtrade.constants import BuySell
 from freqtrade.enums import MarginMode, TradingMode
 from freqtrade.exceptions import (DDosProtection, InsufficientFundsError, InvalidOrderException,
                                   OperationalException, TemporaryError)
@@ -44,7 +45,7 @@ class Ftx(Exchange):
 
     @retrier(retries=0)
     def stoploss(self, pair: str, amount: float, stop_price: float,
-                 order_types: Dict, side: str, leverage: float) -> Dict:
+                 order_types: Dict, side: BuySell, leverage: float) -> Dict:
         """
         Creates a stoploss order.
         depending on order_types.stoploss configuration, uses 'market' or limit order.

freqtrade/exchange/kraken.py

@@ -6,6 +6,7 @@ from typing import Any, Dict, List, Optional, Tuple
 import ccxt
 from pandas import DataFrame
 
+from freqtrade.constants import BuySell
 from freqtrade.enums import MarginMode, TradingMode
 from freqtrade.exceptions import (DDosProtection, InsufficientFundsError, InvalidOrderException,
                                   OperationalException, TemporaryError)
@@ -95,7 +96,7 @@ class Kraken(Exchange):
 
     @retrier(retries=0)
     def stoploss(self, pair: str, amount: float, stop_price: float,
-                 order_types: Dict, side: str, leverage: float) -> Dict:
+                 order_types: Dict, side: BuySell, leverage: float) -> Dict:
         """
         Creates a stoploss market order.
         Stoploss market orders is the only stoploss type supported by kraken.
@@ -165,12 +166,14 @@ class Kraken(Exchange):
 
     def _get_params(
         self,
+        side: BuySell,
         ordertype: str,
         leverage: float,
         reduceOnly: bool,
         time_in_force: str = 'gtc'
     ) -> Dict:
         params = super()._get_params(
+            side=side,
             ordertype=ordertype,
             leverage=leverage,
             reduceOnly=reduceOnly,

freqtrade/exchange/okx.py

@@ -3,6 +3,7 @@ from typing import Dict, List, Tuple
 
 import ccxt
 
+from freqtrade.constants import BuySell
 from freqtrade.enums import MarginMode, TradingMode
 from freqtrade.exceptions import DDosProtection, OperationalException, TemporaryError
 from freqtrade.exchange import Exchange
@@ -34,14 +35,48 @@ class Okx(Exchange):
         (TradingMode.FUTURES, MarginMode.ISOLATED),
     ]
 
+    net_only = True
+
+    @retrier
+    def additional_exchange_init(self) -> None:
+        """
+        Additional exchange initialization logic.
+        .api will be available at this point.
+        Must be overridden in child methods if required.
+        """
+        try:
+            if self.trading_mode == TradingMode.FUTURES and not self._config['dry_run']:
+                accounts = self._api.fetch_accounts()
+                if len(accounts) > 0:
+                    self.net_only = accounts[0].get('info', {}).get('posMode') == 'net_mode'
+        except ccxt.DDoSProtection as e:
+            raise DDosProtection(e) from e
+        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
+            raise TemporaryError(
+                f'Could not set leverage due to {e.__class__.__name__}. Message: {e}') from e
+        except ccxt.BaseError as e:
+            raise OperationalException(e) from e
+
+    def _get_posSide(self, side: BuySell, reduceOnly: bool):
+        if self.net_only:
+            return 'net'
+        if not reduceOnly:
+            # Enter
+            return 'long' if side == 'buy' else 'short'
+        else:
+            # Exit
+            return 'long' if side == 'sell' else 'short'
+
     def _get_params(
         self,
+        side: BuySell,
         ordertype: str,
         leverage: float,
         reduceOnly: bool,
         time_in_force: str = 'gtc',
     ) -> Dict:
         params = super()._get_params(
+            side=side,
             ordertype=ordertype,
             leverage=leverage,
             reduceOnly=reduceOnly,
@@ -49,10 +84,11 @@ class Okx(Exchange):
         )
         if self.trading_mode == TradingMode.FUTURES and self.margin_mode:
             params['tdMode'] = self.margin_mode.value
+            params['posSide'] = self._get_posSide(side, reduceOnly)
         return params
 
     @retrier
-    def _lev_prep(self, pair: str, leverage: float, side: str):
+    def _lev_prep(self, pair: str, leverage: float, side: BuySell):
         if self.trading_mode != TradingMode.SPOT and self.margin_mode is not None:
             try:
                 # TODO-lev: Test me properly (check mgnMode passed)
@@ -61,7 +97,7 @@ class Okx(Exchange):
                     symbol=pair,
                     params={
                         "mgnMode": self.margin_mode.value,
-                        # "posSide": "net"",
+                        "posSide": self._get_posSide(side, False),
                     })
             except ccxt.DDoSProtection as e:
                 raise DDosProtection(e) from e

freqtrade/freqtradebot.py

@@ -14,7 +14,7 @@ from schedule import Scheduler
 
 from freqtrade import __version__, constants
 from freqtrade.configuration import validate_config_consistency
-from freqtrade.constants import LongShort
+from freqtrade.constants import BuySell, LongShort
 from freqtrade.data.converter import order_book_to_dataframe
 from freqtrade.data.dataprovider import DataProvider
 from freqtrade.edge import Edge
@@ -23,6 +23,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
@@ -191,8 +192,8 @@ class FreqtradeBot(LoggingMixin):
         self.strategy.analyze(self.active_pair_whitelist)
 
         with self._exit_lock:
-            # Check and handle any timed out open orders
-            self.check_handle_timedout()
+            # Check for exchange cancelations, timeouts and user requested replace
+            self.manage_open_orders()
 
         # Protect from collisions with force_exit.
         # Without this, freqtrade my try to recreate stoploss_on_exchange orders
@@ -616,7 +617,8 @@ class FreqtradeBot(LoggingMixin):
         """
         time_in_force = self.strategy.order_time_in_force['entry']
 
-        [side, name] = ['sell', 'Short'] if is_short else ['buy', 'Long']
+        side: BuySell = 'sell' if is_short else 'buy'
+        name = 'Short' if is_short else 'Long'
         trade_side: LongShort = 'short' if is_short else 'long'
         pos_adjust = trade is not None
 
@@ -1140,13 +1142,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
-        :param timeoutvalue: Number of minutes until order is considered timed out
+        Management of open orders on exchange. Unfilled orders might be cancelled if timeout
+        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:
@@ -1157,34 +1159,88 @@ 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(
-                trade, order_obj, datetime.now(timezone.utc)))
-            ):
-                if is_entering:
+            if not_closed:
+                if fully_cancelled or (order_obj and self.strategy.ft_check_timed_out(
+                   trade, order_obj, datetime.now(timezone.utc))):
+                    self.handle_timedout_order(order, trade)
+                else:
+                    self.replace_order(order, order_obj, trade)
+
+    def handle_timedout_order(self, order: Dict, trade: Trade) -> None:
+        """
+        Check if current analyzed order timed out and cancel if necessary.
+        :param order: Order dict grabbed with exchange.fetch_order()
+        :param trade: Trade object.
+        :return: None
+        """
+        if order['side'] == trade.entry_side:
             self.handle_cancel_enter(trade, order, constants.CANCEL_REASON['TIMEOUT'])
         else:
             canceled = self.handle_cancel_exit(
                 trade, order, constants.CANCEL_REASON['TIMEOUT'])
             canceled_count = trade.get_exit_order_count()
-                    max_timeouts = self.config.get(
-                        'unfilledtimeout', {}).get('exit_timeout_count', 0)
+            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.get('price'),
+                        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:
         """
         Cancel all orders that are currently open
@@ -1205,7 +1261,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
@@ -1243,9 +1302,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']}"
@@ -1622,7 +1682,6 @@ class FreqtradeBot(LoggingMixin):
                 # TODO: Margin will need to use interest_rate as well.
                 # interest_rate = self.exchange.get_interest_rate()
                 trade.set_isolated_liq(self.exchange.get_liquidation_price(
-
                     leverage=trade.leverage,
                     pair=trade.pair,
                     amount=trade.amount,

freqtrade/optimize/backtesting.py

@@ -732,19 +732,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
@@ -826,7 +832,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)
@@ -886,13 +892,26 @@ 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.
-        Returns True if the trade should be Deleted (initial order was canceled).
+        Check if any open order needs to be cancelled or replaced.
+        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
 
+    def check_order_cancel(self, trade: LocalTrade, order: Order, current_time) -> bool:
+        """
+        Check if current analyzed order has to be canceled.
+        Returns True if the trade should be Deleted (initial order was canceled).
+        """
         timedout = self.strategy.ft_check_timed_out(trade, order, current_time)
         if timedout:
             if order.side == trade.entry_side:
@@ -910,6 +929,41 @@ class Backtesting:
 
         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:
@@ -979,9 +1033,9 @@ class Backtesting:
                 self.dataprovider._set_dataframe_max_index(row_index)
 
                 for t in list(open_trades[pair]):
-                    # 1. Cancel expired entry/exit orders.
-                    if self.check_order_cancel(t, current_time):
-                        # Close trade due to entry timeout expiration.
+                    # 1. Manage currently open orders of active trades
+                    if self.manage_open_orders(t, current_time, row):
+                        # Close trade
                         open_trade_count -= 1
                         open_trades[pair].remove(t)
                         self.wallets.update()
@@ -1012,7 +1066,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()
@@ -1027,7 +1081,7 @@ class Backtesting:
                         trade.open_order_id = None
                         sub_trade = order.safe_amount_after_fee != trade.amount
                         if sub_trade:
-                            order.close_bt_order(current_time)
+                            order.close_bt_order(current_time, trade)
                             trade.process_exit_sub_trade(order)
                             trade.recalc_trade_from_orders()
                         else:

freqtrade/persistence/models.py

@@ -15,7 +15,7 @@ from sqlalchemy.pool import StaticPool
 from sqlalchemy.sql.schema import UniqueConstraint
 
 from freqtrade.constants import (DATETIME_PRINT_FORMAT, MATH_CLOSE_PREC, NON_OPEN_EXCHANGE_STATES,
-                                 LongShort)
+                                 BuySell, LongShort)
 from freqtrade.enums import ExitType, TradingMode
 from freqtrade.exceptions import DependencyException, OperationalException
 from freqtrade.leverage import interest
@@ -221,11 +221,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]):
@@ -389,7 +393,7 @@ class LocalTrade():
             return "buy"
 
     @property
-    def exit_side(self) -> str:
+    def exit_side(self) -> BuySell:
         if self.is_short:
             return "buy"
         else:

freqtrade/plot/plotting.py

@@ -634,6 +634,7 @@ def load_and_plot_trades(config: Dict[str, Any]):
     exchange = ExchangeResolver.load_exchange(config['exchange']['name'], config)
     IStrategy.dp = DataProvider(config, exchange)
     strategy.bot_start()
+    strategy.bot_loop_start()
     plot_elements = init_plotscript(config, list(exchange.markets), strategy.startup_candle_count)
     timerange = plot_elements['timerange']
     trades = plot_elements['trades']

freqtrade/plugins/protections/low_profit_pairs.py

@@ -21,6 +21,7 @@ class LowProfitPairs(IProtection):
 
         self._trade_limit = protection_config.get('trade_limit', 1)
         self._required_profit = protection_config.get('required_profit', 0.0)
+        self._only_per_side = protection_config.get('only_per_side', False)
 
     def short_desc(self) -> str:
         """
@@ -36,7 +37,8 @@ class LowProfitPairs(IProtection):
         return (f'{profit} < {self._required_profit} in {self.lookback_period_str}, '
                 f'locking for {self.stop_duration_str}.')
 
-    def _low_profit(self, date_now: datetime, pair: str) -> Optional[ProtectionReturn]:
+    def _low_profit(
+            self, date_now: datetime, pair: str, side: LongShort) -> Optional[ProtectionReturn]:
         """
         Evaluate recent trades for pair
         """
@@ -54,7 +56,10 @@ class LowProfitPairs(IProtection):
             # Not enough trades in the relevant period
             return None
 
-        profit = sum(trade.close_profit for trade in trades if trade.close_profit)
+        profit = sum(
+            trade.close_profit for trade in trades if trade.close_profit
+            and (not self._only_per_side or trade.trade_direction == side)
+            )
         if profit < self._required_profit:
             self.log_once(
                 f"Trading for {pair} stopped due to {profit:.2f} < {self._required_profit} "
@@ -65,6 +70,7 @@ class LowProfitPairs(IProtection):
                 lock=True,
                 until=until,
                 reason=self._reason(profit),
+                lock_side=(side if self._only_per_side else '*')
             )
 
         return None
@@ -86,4 +92,4 @@ class LowProfitPairs(IProtection):
         :return: Tuple of [bool, until, reason].
             If true, this pair will be locked with <reason> until <until>
         """
-        return self._low_profit(date_now, pair=pair)
+        return self._low_profit(date_now, pair=pair, side=side)

freqtrade/plugins/protections/stoploss_guard.py

@@ -38,8 +38,8 @@ class StoplossGuard(IProtection):
         return (f'{self._trade_limit} stoplosses in {self._lookback_period} min, '
                 f'locking for {self._stop_duration} min.')
 
-    def _stoploss_guard(
-            self, date_now: datetime, pair: Optional[str], side: str) -> Optional[ProtectionReturn]:
+    def _stoploss_guard(self, date_now: datetime, pair: Optional[str],
+                        side: LongShort) -> Optional[ProtectionReturn]:
         """
         Evaluate recent trades
         """

freqtrade/rpc/api_server/api_backtest.py

@@ -172,6 +172,7 @@ def api_delete_backtest(ws_mode=Depends(is_webserver_mode)):
             "status_msg": "Backtest running",
         }
     if ApiServer._bt:
+        ApiServer._bt.cleanup()
         del ApiServer._bt
         ApiServer._bt = None
         del ApiServer._bt_data

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.

requirements.txt

@@ -2,7 +2,7 @@ numpy==1.22.3
 pandas==1.4.2
 pandas-ta==0.3.14b
 
-ccxt==1.81.16
+ccxt==1.81.43
 # Pin cryptography for now due to rust build errors with piwheels
 cryptography==37.0.1
 aiohttp==3.8.1

tests/exchange/test_ccxt_compat.py

@@ -135,6 +135,7 @@ def exchange_futures(request, exchange_conf, class_mocker):
         class_mocker.patch(
             'freqtrade.exchange.binance.Binance.fill_leverage_tiers')
         class_mocker.patch('freqtrade.exchange.exchange.Exchange.fetch_trading_fees')
+        class_mocker.patch('freqtrade.exchange.okx.Okx.additional_exchange_init')
         exchange = ExchangeResolver.load_exchange(request.param, exchange_conf, validate=True)
 
         yield exchange, request.param

tests/exchange/test_exchange.py

@@ -150,6 +150,8 @@ def test_remove_credentials(default_conf, caplog) -> None:
 def test_init_ccxt_kwargs(default_conf, mocker, caplog):
     mocker.patch('freqtrade.exchange.Exchange._load_markets', MagicMock(return_value={}))
     mocker.patch('freqtrade.exchange.Exchange.validate_stakecurrency')
+    aei_mock = mocker.patch('freqtrade.exchange.Exchange.additional_exchange_init')
+
     caplog.set_level(logging.INFO)
     conf = copy.deepcopy(default_conf)
     conf['exchange']['ccxt_async_config'] = {'aiohttp_trust_env': True, 'asyncio_loop': True}
@@ -159,6 +161,7 @@ def test_init_ccxt_kwargs(default_conf, mocker, caplog):
         caplog)
     assert ex._api_async.aiohttp_trust_env
     assert not ex._api.aiohttp_trust_env
+    assert aei_mock.call_count == 1
 
     # Reset logging and config
     caplog.clear()
@@ -4833,8 +4836,10 @@ def test__get_params(mocker, default_conf, exchange_name):
 
     if exchange_name == 'okx':
         params2['tdMode'] = 'isolated'
+        params2['posSide'] = 'net'
 
     assert exchange._get_params(
+        side="buy",
         ordertype='market',
         reduceOnly=False,
         time_in_force='gtc',
@@ -4842,6 +4847,7 @@ def test__get_params(mocker, default_conf, exchange_name):
     ) == params1
 
     assert exchange._get_params(
+        side="buy",
         ordertype='market',
         reduceOnly=False,
         time_in_force='ioc',
@@ -4849,6 +4855,7 @@ def test__get_params(mocker, default_conf, exchange_name):
     ) == params1
 
     assert exchange._get_params(
+        side="buy",
         ordertype='limit',
         reduceOnly=False,
         time_in_force='gtc',
@@ -4861,6 +4868,7 @@ def test__get_params(mocker, default_conf, exchange_name):
     exchange._params = {'test': True}
 
     assert exchange._get_params(
+        side="buy",
         ordertype='limit',
         reduceOnly=True,
         time_in_force='ioc',

tests/exchange/test_okx.py

@@ -1,7 +1,10 @@
 from unittest.mock import MagicMock, PropertyMock
 
+import pytest
+
 from freqtrade.enums import MarginMode, TradingMode
 from tests.conftest import get_patched_exchange
+from tests.exchange.test_exchange import ccxt_exceptionhandlers
 
 
 def test_get_maintenance_ratio_and_amt_okx(
@@ -170,6 +173,70 @@ def test_get_max_pair_stake_amount_okx(default_conf, mocker, leverage_tiers):
     assert exchange.get_max_pair_stake_amount('TTT/USDT', 1.0) == float('inf')  # Not in tiers
 
 
+@pytest.mark.parametrize('mode,side,reduceonly,result', [
+    ('net', 'buy', False, 'net'),
+    ('net', 'sell', True, 'net'),
+    ('net', 'sell', False, 'net'),
+    ('net', 'buy', True, 'net'),
+    ('longshort', 'buy', False, 'long'),
+    ('longshort', 'sell', True, 'long'),
+    ('longshort', 'sell', False, 'short'),
+    ('longshort', 'buy', True, 'short'),
+])
+def test__get_posSide(default_conf, mocker, mode, side, reduceonly, result):
+
+    exchange = get_patched_exchange(mocker, default_conf, id="okx")
+    exchange.net_only = mode == 'net'
+    assert exchange._get_posSide(side, reduceonly) == result
+
+
+def test_additional_exchange_init_okx(default_conf, mocker):
+    api_mock = MagicMock()
+    api_mock.fetch_accounts = MagicMock(return_value=[
+        {'id': '2555',
+         'type': '2',
+         'currency': None,
+         'info': {'acctLv': '2',
+                  'autoLoan': False,
+                  'ctIsoMode': 'automatic',
+                  'greeksType': 'PA',
+                  'level': 'Lv1',
+                  'levelTmp': '',
+                  'mgnIsoMode': 'automatic',
+                  'posMode': 'long_short_mode',
+                  'uid': '2555'}}])
+    default_conf['dry_run'] = False
+    exchange = get_patched_exchange(mocker, default_conf, id="okx", api_mock=api_mock)
+    assert api_mock.fetch_accounts.call_count == 0
+    exchange.trading_mode = TradingMode.FUTURES
+    # Default to netOnly
+    assert exchange.net_only
+    exchange.additional_exchange_init()
+    assert api_mock.fetch_accounts.call_count == 1
+    assert not exchange.net_only
+
+    api_mock.fetch_accounts = MagicMock(return_value=[
+            {'id': '2555',
+             'type': '2',
+             'currency': None,
+             'info': {'acctLv': '2',
+                      'autoLoan': False,
+                      'ctIsoMode': 'automatic',
+                      'greeksType': 'PA',
+                      'level': 'Lv1',
+                      'levelTmp': '',
+                      'mgnIsoMode': 'automatic',
+                      'posMode': 'net_mode',
+                      'uid': '2555'}}])
+    exchange.additional_exchange_init()
+    assert api_mock.fetch_accounts.call_count == 1
+    assert exchange.net_only
+    default_conf['trading_mode'] = 'futures'
+    default_conf['margin_mode'] = 'isolated'
+    ccxt_exceptionhandlers(mocker, default_conf, api_mock, 'okx',
+                           "additional_exchange_init", "fetch_accounts")
+
+
 def test_load_leverage_tiers_okx(default_conf, mocker, markets):
     api_mock = MagicMock()
     type(api_mock).has = PropertyMock(return_value={

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/plugins/test_protections.py

@@ -250,14 +250,16 @@ def test_CooldownPeriod(mocker, default_conf, fee, caplog):
     assert not PairLocks.is_global_lock()
 
 
+@pytest.mark.parametrize('only_per_side', [False, True])
 @pytest.mark.usefixtures("init_persistence")
-def test_LowProfitPairs(mocker, default_conf, fee, caplog):
+def test_LowProfitPairs(mocker, default_conf, fee, caplog, only_per_side):
     default_conf['protections'] = [{
         "method": "LowProfitPairs",
         "lookback_period": 400,
         "stop_duration": 60,
         "trade_limit": 2,
         "required_profit": 0.0,
+        "only_per_side": only_per_side,
     }]
     freqtrade = get_patched_freqtradebot(mocker, default_conf)
     message = r"Trading stopped due to .*"
@@ -292,10 +294,11 @@ def test_LowProfitPairs(mocker, default_conf, fee, caplog):
     # Add positive trade
     Trade.query.session.add(generate_mock_trade(
         'XRP/BTC', fee.return_value, False, exit_reason=ExitType.ROI.value,
-        min_ago_open=20, min_ago_close=10, profit_rate=1.15,
+        min_ago_open=20, min_ago_close=10, profit_rate=1.15, is_short=True
     ))
-    assert not freqtrade.protections.stop_per_pair('XRP/BTC')
-    assert not PairLocks.is_pair_locked('XRP/BTC')
+    assert freqtrade.protections.stop_per_pair('XRP/BTC') != only_per_side
+    assert not PairLocks.is_pair_locked('XRP/BTC', side='*')
+    assert PairLocks.is_pair_locked('XRP/BTC', side='long') == only_per_side
 
     Trade.query.session.add(generate_mock_trade(
         'XRP/BTC', fee.return_value, False, exit_reason=ExitType.STOP_LOSS.value,
@@ -303,9 +306,10 @@ def test_LowProfitPairs(mocker, default_conf, fee, caplog):
     ))
 
     # Locks due to 2nd trade
-    assert not freqtrade.protections.global_stop()
-    assert freqtrade.protections.stop_per_pair('XRP/BTC')
-    assert PairLocks.is_pair_locked('XRP/BTC')
+    assert freqtrade.protections.global_stop() != only_per_side
+    assert freqtrade.protections.stop_per_pair('XRP/BTC') != only_per_side
+    assert PairLocks.is_pair_locked('XRP/BTC', side='long')
+    assert PairLocks.is_pair_locked('XRP/BTC', side='*') != only_per_side
     assert not PairLocks.is_global_lock()
 
 

tests/test_freqtradebot.py

@@ -2364,7 +2364,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:
@@ -2396,12 +2396,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)
@@ -2409,7 +2409,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)
@@ -2418,7 +2418,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()
@@ -2428,7 +2428,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:
@@ -2454,8 +2454,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()
@@ -2463,6 +2464,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])
@@ -2488,18 +2582,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 nb_trades == 0
+    assert len(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)
@@ -2519,7 +2612,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()
@@ -2528,7 +2621,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:
@@ -2559,13 +2652,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
@@ -2575,7 +2668,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
@@ -2585,7 +2678,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
@@ -2598,7 +2691,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')
@@ -2608,16 +2701,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)
@@ -2644,7 +2737,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
@@ -2680,7 +2773,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
@@ -2690,7 +2783,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:
@@ -2716,7 +2809,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()
@@ -2727,7 +2820,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
@@ -2759,7 +2852,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)
 
@@ -2776,7 +2869,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
@@ -2807,7 +2900,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)
 
@@ -2823,7 +2916,7 @@ 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:
     patch_RPCManager(mocker)
     patch_exchange(mocker)
@@ -2845,7 +2938,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="
@@ -3411,7 +3504,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
@@ -3463,7 +3556,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
@@ -5233,7 +5326,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
@@ -5339,7 +5432,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