OctoBot-Trading 2.4.57__tar.gz → 2.4.59__tar.gz

{OctoBot-Trading-2.4.57 → OctoBot-Trading-2.4.59}/CHANGELOG.md

@@ -4,6 +4,15 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.4.59] - 2024-03-11
+### Fixed
+- [TradingModes] Fix convert_asset_to_target_asset to properly handle fees
+
+## [2.4.58] - 2024-03-07
+### Fixed
+- [ChainedOrders] Outdated limit price
+- [Backtesting] Invalid order fill price
+
 ## [2.4.57] - 2024-03-06
 ### Updated
 - [Exchange] log last request url on failed retry

{OctoBot-Trading-2.4.57 → OctoBot-Trading-2.4.59/OctoBot_Trading.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: OctoBot-Trading
-Version: 2.4.57
+Version: 2.4.59
 Summary: OctoBot project trading package
 Home-page: https://github.com/Drakkar-Software/OctoBot-Trading
 Author: Drakkar-Software
@@ -16,7 +16,7 @@ Classifier: Operating System :: POSIX
 Requires-Python: >=3.8
 License-File: LICENSE
 
-# OctoBot-Trading [2.4.57](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
+# OctoBot-Trading [2.4.59](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
 [![Codacy Badge](https://api.codacy.com/project/badge/Grade/903b6b22bceb4661b608a86fea655f69)](https://app.codacy.com/gh/Drakkar-Software/OctoBot-Trading?utm_source=github.com&utm_medium=referral&utm_content=Drakkar-Software/OctoBot-Trading&utm_campaign=Badge_Grade_Dashboard)
 [![PyPI](https://img.shields.io/pypi/v/OctoBot-Trading.svg)](https://pypi.python.org/pypi/OctoBot-Trading/)
 [![Coverage Status](https://coveralls.io/repos/github/Drakkar-Software/OctoBot-Trading/badge.svg?branch=master)](https://coveralls.io/github/Drakkar-Software/OctoBot-Trading?branch=master)

{OctoBot-Trading-2.4.57 → OctoBot-Trading-2.4.59}/OctoBot_Trading.egg-info/SOURCES.txt

@@ -378,6 +378,7 @@ tests/personal_data/orders/types/__init__.py
 tests/personal_data/orders/types/test_unknown_order.py
 tests/personal_data/orders/types/limit/__init__.py
 tests/personal_data/orders/types/limit/test_buy_limit_order.py
+tests/personal_data/orders/types/limit/test_limit_order.py
 tests/personal_data/orders/types/limit/test_sell_limit_order.py
 tests/personal_data/orders/types/limit/test_stop_loss_limit_order.py
 tests/personal_data/orders/types/limit/test_stop_loss_order.py

{OctoBot-Trading-2.4.57/OctoBot_Trading.egg-info → OctoBot-Trading-2.4.59}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: OctoBot-Trading
-Version: 2.4.57
+Version: 2.4.59
 Summary: OctoBot project trading package
 Home-page: https://github.com/Drakkar-Software/OctoBot-Trading
 Author: Drakkar-Software
@@ -16,7 +16,7 @@ Classifier: Operating System :: POSIX
 Requires-Python: >=3.8
 License-File: LICENSE
 
-# OctoBot-Trading [2.4.57](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
+# OctoBot-Trading [2.4.59](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
 [![Codacy Badge](https://api.codacy.com/project/badge/Grade/903b6b22bceb4661b608a86fea655f69)](https://app.codacy.com/gh/Drakkar-Software/OctoBot-Trading?utm_source=github.com&utm_medium=referral&utm_content=Drakkar-Software/OctoBot-Trading&utm_campaign=Badge_Grade_Dashboard)
 [![PyPI](https://img.shields.io/pypi/v/OctoBot-Trading.svg)](https://pypi.python.org/pypi/OctoBot-Trading/)
 [![Coverage Status](https://coveralls.io/repos/github/Drakkar-Software/OctoBot-Trading/badge.svg?branch=master)](https://coveralls.io/github/Drakkar-Software/OctoBot-Trading?branch=master)

{OctoBot-Trading-2.4.57 → OctoBot-Trading-2.4.59}/README.md

@@ -1,4 +1,4 @@
-# OctoBot-Trading [2.4.57](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
+# OctoBot-Trading [2.4.59](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
 [![Codacy Badge](https://api.codacy.com/project/badge/Grade/903b6b22bceb4661b608a86fea655f69)](https://app.codacy.com/gh/Drakkar-Software/OctoBot-Trading?utm_source=github.com&utm_medium=referral&utm_content=Drakkar-Software/OctoBot-Trading&utm_campaign=Badge_Grade_Dashboard)
 [![PyPI](https://img.shields.io/pypi/v/OctoBot-Trading.svg)](https://pypi.python.org/pypi/OctoBot-Trading/)
 [![Coverage Status](https://coveralls.io/repos/github/Drakkar-Software/OctoBot-Trading/badge.svg?branch=master)](https://coveralls.io/github/Drakkar-Software/OctoBot-Trading?branch=master)

{OctoBot-Trading-2.4.57 → OctoBot-Trading-2.4.59}/octobot_trading/__init__.py

@@ -15,4 +15,4 @@
 #  License along with this library.
 
 PROJECT_NAME = "OctoBot-Trading"
-VERSION = "2.4.57"  # major.minor.revision
+VERSION = "2.4.59"  # major.minor.revision

{OctoBot-Trading-2.4.57 → OctoBot-Trading-2.4.59}/octobot_trading/api/symbol_data.py

@@ -13,6 +13,8 @@
 #
 #  You should have received a copy of the GNU Lesser General Public
 #  License along with this library.
+import decimal
+
 import octobot_commons.enums
 
 import octobot_trading.enums
@@ -105,7 +107,7 @@ def create_new_candles_manager(candles=None, max_candles_count=None) -> exchange
 
 def force_set_mark_price(exchange_manager, symbol, price):
     exchange_manager.exchange_symbols_data.get_exchange_symbol_data(symbol).prices_manager.\
-        set_mark_price(price, octobot_trading.enums.MarkPriceSources.EXCHANGE_MARK_PRICE.value)
+        set_mark_price(decimal.Decimal(str(price)), octobot_trading.enums.MarkPriceSources.EXCHANGE_MARK_PRICE.value)
 
 
 def is_mark_price_initialized(exchange_manager, symbol: str) -> bool:

{OctoBot-Trading-2.4.57 → OctoBot-Trading-2.4.59}/octobot_trading/constants.py

@@ -39,6 +39,8 @@ ALLOW_SIMULATED_ORDERS_INSTANT_FILL = os_util.parse_boolean_environment_var(
 
 # Order creation
 ORDER_DATA_FETCHING_TIMEOUT = 5 * commons_constants.MINUTE_TO_SECONDS
+CHAINED_ORDER_PRICE_FETCHING_TIMEOUT = 1    # should be instant or ignored
+CHAINED_ORDERS_OUTDATED_PRICE_ALLOWANCE = decimal.Decimal("0.005")  # allows 0.5% outdated price error
 
 # Tentacles
 TRADING_MODE_REQUIRED_STRATEGIES = "required_strategies"

{OctoBot-Trading-2.4.57 → OctoBot-Trading-2.4.59}/octobot_trading/exchange_data/prices/price_events_manager.py

@@ -49,6 +49,12 @@ class PriceEventsManager:
         self.clear_recent_prices()
         self.events.clear()
 
+    def get_min_and_max_prices(self) -> (float, float):
+        if len(self._last_recent_prices) < 2:
+            raise IndexError("Not enough data")
+        prices = sorted([element[self.PRICE_KEY] for element in self._last_recent_prices])
+        return prices[0], prices[-1]
+
     def handle_recent_trades(self, recent_trades):
         """
         Handle new recent trades prices

{OctoBot-Trading-2.4.57 → OctoBot-Trading-2.4.59}/octobot_trading/modes/modes_util.py

@@ -151,19 +151,29 @@ def _get_associated_symbol_and_order_type(trading_mode, asset: str, target_asset
 
 
 def _get_available_or_target_quantity(trading_mode, symbol, order_type, price, asset_amount) -> decimal.Decimal:
+    side = (
+        trading_enums.TradeOrderSide.SELL
+        if order_type in (trading_enums.TraderOrderType.SELL_MARKET, trading_enums.TraderOrderType.SELL_LIMIT)
+        else trading_enums.TradeOrderSide.BUY
+    )
+
+    currency_available, market_available, market_quantity = trading_personal_data.get_portfolio_amounts(
+        trading_mode.exchange_manager, symbol, price, portfolio_type=common_constants.PORTFOLIO_AVAILABLE
+    )
     if asset_amount is None:
-        currency_available, _, market_quantity = trading_personal_data.get_portfolio_amounts(
-            trading_mode.exchange_manager, symbol, price, portfolio_type=common_constants.PORTFOLIO_AVAILABLE
-        )
-        quantity = currency_available if order_type is trading_enums.TraderOrderType.SELL_MARKET \
-            else market_quantity
+        quantity = currency_available if side is trading_enums.TradeOrderSide.SELL else market_quantity
     else:
         try:
-            quantity = asset_amount if order_type is trading_enums.TraderOrderType.SELL_MARKET \
-                else (asset_amount / price)
+            quantity = asset_amount if side is trading_enums.TradeOrderSide.SELL else (asset_amount / price)
         except (decimal.DivisionByZero, decimal.InvalidOperation):
             quantity = constants.ZERO
-    return quantity
+
+    adapted_quantity = trading_personal_data.decimal_adapt_order_quantity_because_fees(
+        trading_mode.exchange_manager, symbol, order_type, quantity, price,
+        trading_enums.ExchangeConstantsMarketPropertyColumns.TAKER, side,
+        currency_available if side is trading_enums.TradeOrderSide.SELL else market_available
+    )
+    return adapted_quantity
 
 
 async def notify_portfolio_optimization_complete():

{OctoBot-Trading-2.4.57 → OctoBot-Trading-2.4.59}/octobot_trading/personal_data/orders/order.py

@@ -484,12 +484,15 @@ class Order(util.Initializable):
             logger.debug(f"Updating chained order quantity with triggering order fees. {fees_str}")
         return True
 
+    async def update_price_if_outdated(self):
+        """
+        Implement if necessary
+        """
+
     async def _trigger_chained_orders(self):
         logger = logging.get_logger(self.get_logger_name())
         for index, order in enumerate(self.chained_orders):
-            can_be_created = True
-            if order.update_with_triggering_order_fees:
-                can_be_created = order.update_quantity_with_order_fees(self)
+            can_be_created = await order_util.adapt_chained_order_before_creation(self, order)
             if can_be_created and order.should_be_created():
                 logger.debug(f"Creating chained order {index + 1}/{len(self.chained_orders)}")
                 await order_util.create_as_chained_order(order)
@@ -721,6 +724,15 @@ class Order(util.Initializable):
             # quantity in USDT for BTC/USDT => cost = price(BTC in USDT)
             self.total_cost = quantity
 
+    def update_order_filled_values(self, ideal_price: decimal.Decimal):
+        if not self.filled_price:
+            # keep order.filled_price if already set (!= 0)
+            self.filled_price = order_util.get_valid_filled_price(self, ideal_price)
+        if not self.filled_quantity or self.exchange_manager.trader.simulate:
+            # keep self.filled_quantity if already set (!= 0) in real trading
+            self.filled_quantity = self.origin_quantity
+        self._update_total_cost()
+
     def consider_as_canceled(self):
         self.status = enums.OrderStatus.CANCELED
         if self.canceled_time == 0:

{OctoBot-Trading-2.4.57 → OctoBot-Trading-2.4.59}/octobot_trading/personal_data/orders/order_util.py

@@ -551,6 +551,46 @@ def generate_order_id():
     return str(uuid.uuid4())
 
 
+def _get_possible_filled_price(
+    exchange_manager, symbol: str, side: enums.TradeOrderSide, ideal_price: decimal.Decimal
+) -> decimal.Decimal:
+    try:
+        min_price, max_price = exchange_manager.exchange_symbols_data.get_exchange_symbol_data(symbol).\
+            price_events_manager.get_min_and_max_prices()
+        if side is enums.TradeOrderSide.SELL:
+            if ideal_price < min_price:
+                return min_price
+        if side is enums.TradeOrderSide.BUY:
+            if ideal_price > max_price:
+                return max_price
+    except IndexError:
+        # no available price data
+        pass
+    return ideal_price
+
+
+def get_valid_filled_price(order, ideal_price: decimal.Decimal):
+    # ensure filled price based on ideal_price makes sense according to the current candle
+    # instead of blindly using ideal_price as this could
+    # potentially buy higher than the candle high or sell lower than the candle low,
+    # which can't happen on real conditions
+
+    if order.exchange_manager.is_backtesting:
+        # in backtesting: ensure ideal_price is with in current candle price.
+        return _get_possible_filled_price(order.exchange_manager, order.symbol, order.side, ideal_price)
+    # not in backtesting: price desync can't happen
+    return ideal_price
+
+
+async def adapt_chained_order_before_creation(base_order, chained_order):
+    can_be_created = True
+    if chained_order.update_with_triggering_order_fees:
+        can_be_created = chained_order.update_quantity_with_order_fees(base_order)
+    # ensure price is not outdated
+    await chained_order.update_price_if_outdated()
+    return can_be_created
+
+
 async def wait_for_order_fill(order, timeout, wait_for_portfolio_update):
     if order.is_open():
         if order.state is None:

{OctoBot-Trading-2.4.57 → OctoBot-Trading-2.4.59}/octobot_trading/personal_data/orders/types/limit/limit_order.py

@@ -18,6 +18,7 @@ import asyncio
 import octobot_trading.enums as enums
 import octobot_trading.constants as constants
 import octobot_trading.personal_data.orders.order as order_class
+import octobot_trading.personal_data.orders.decimal_order_adapter as decimal_order_adapter
 
 
 class LimitOrder(order_class.Order):
@@ -36,6 +37,38 @@ class LimitOrder(order_class.Order):
             self.trigger_above = raw_order[enums.ExchangeConstantsOrderColumns.TRIGGER_ABOVE.value]
         return updated
 
+    async def update_price_if_outdated(self):
+        # price is outdated if it would trigger and instantly filled order with more than the allowed tolerance
+        try:
+            current_price = await self.exchange_manager.exchange_symbols_data.get_exchange_symbol_data(self.symbol) \
+                .prices_manager.get_mark_price(timeout=constants.CHAINED_ORDER_PRICE_FETCHING_TIMEOUT)
+            self._update_limit_price_if_necessary(current_price)
+        except asyncio.TimeoutError:
+            # price can't be checked
+            return
+
+    def _update_limit_price_if_necessary(self, current_price):
+        updated_price = self.origin_price
+        if self.side is enums.TradeOrderSide.BUY:
+            highest_accepted_buy_price = (
+                current_price * (constants.ONE + constants.CHAINED_ORDERS_OUTDATED_PRICE_ALLOWANCE)
+            )
+            if self.origin_price > highest_accepted_buy_price:
+                # buy price is more than CHAINED_ORDERS_OUTDATED_PRICE_ALLOWANCE % higher than the current price
+                # => Reduce it to the highest allowed price
+                updated_price = highest_accepted_buy_price
+        if self.side is enums.TradeOrderSide.SELL:
+            lowest_accepted_sell_price = (
+                current_price * (constants.ONE - constants.CHAINED_ORDERS_OUTDATED_PRICE_ALLOWANCE)
+            )
+            if self.origin_price < lowest_accepted_sell_price:
+                # sell price is more than CHAINED_ORDERS_OUTDATED_PRICE_ALLOWANCE % lower than the current price
+                # => Increase it to the current price
+                updated_price = lowest_accepted_sell_price
+        if self.origin_price != updated_price:
+            symbol_market = self.exchange_manager.exchange.get_market_status(self.symbol, with_fixer=False)
+            self.origin_price = decimal_order_adapter.decimal_adapt_price(symbol_market, updated_price)
+
     async def update_order_status(self, force_refresh=False):
         if self.limit_price_hit_event is None:
             self._create_hit_event(self.creation_time)
@@ -87,9 +120,7 @@ class LimitOrder(order_class.Order):
 
     def on_fill_actions(self):
         self.taker_or_maker = self._filled_maker_or_taker()
-        self.filled_price = self.origin_price
-        self.filled_quantity = self.origin_quantity
-        self._update_total_cost()
+        self.update_order_filled_values(self.origin_price)
         order_class.Order.on_fill_actions(self)
 
     def clear(self):

{OctoBot-Trading-2.4.57 → OctoBot-Trading-2.4.59}/octobot_trading/personal_data/orders/types/limit/stop_loss_limit_order.py

@@ -31,6 +31,9 @@ class StopLossLimitOrder(limit_order.LimitOrder):
     def is_counted_in_available_funds(self):
         return False
 
+    async def update_price_if_outdated(self):
+        pass
+
     async def on_filled(self, enable_associated_orders_creation):
         await limit_order.LimitOrder.on_filled(self, enable_associated_orders_creation)
         # TODO replace with chained order ?

{OctoBot-Trading-2.4.57 → OctoBot-Trading-2.4.59}/octobot_trading/personal_data/orders/types/limit/stop_loss_order.py

@@ -25,6 +25,9 @@ class StopLossOrder(limit_order.LimitOrder):
     def is_counted_in_available_funds(self):
         return False
 
+    async def update_price_if_outdated(self):
+        pass
+
     def _filled_maker_or_taker(self):
         # Creates a market order when filled, which is taker
         return enums.ExchangeConstantsMarketPropertyColumns.TAKER.value

{OctoBot-Trading-2.4.57 → OctoBot-Trading-2.4.59}/octobot_trading/personal_data/orders/types/limit/take_profit_limit_order.py

@@ -26,6 +26,9 @@ class TakeProfitLimitOrder(limit_order.LimitOrder):
         super().__init__(trader, side)
         self.limit_price = limit_price
 
+    async def update_price_if_outdated(self):
+        pass
+
     async def on_filled(self, enable_associated_orders_creation):
         await limit_order.LimitOrder.on_filled(self, enable_associated_orders_creation)
         # TODO replace with chained order ?

{OctoBot-Trading-2.4.57 → OctoBot-Trading-2.4.59}/octobot_trading/personal_data/orders/types/limit/take_profit_order.py

@@ -25,6 +25,9 @@ class TakeProfitOrder(limit_order.LimitOrder):
     def is_counted_in_available_funds(self):
         return False
 
+    async def update_price_if_outdated(self):
+        pass
+
     def _filled_maker_or_taker(self):
         # Creates a market order when filled, which is taker
         return enums.ExchangeConstantsMarketPropertyColumns.TAKER.value

{OctoBot-Trading-2.4.57 → OctoBot-Trading-2.4.59}/octobot_trading/personal_data/orders/types/market/market_order.py

@@ -30,9 +30,7 @@ class MarketOrder(order_class.Order):
     def on_fill_actions(self):
         self.taker_or_maker = enums.ExchangeConstantsMarketPropertyColumns.TAKER.value
         self.origin_price = self.created_last_price
-        self.filled_price = self.created_last_price
-        self.filled_quantity = self.origin_quantity
-        self._update_total_cost()
+        self.update_order_filled_values(self.created_last_price)
         order_class.Order.on_fill_actions(self)
 
     def can_be_edited(self):

{OctoBot-Trading-2.4.57 → OctoBot-Trading-2.4.59}/tests/modes/test_modes_util.py

@@ -195,6 +195,54 @@ async def test_convert_asset_to_target_asset(backtesting_trader):
     trading_mode.create_order.assert_called_once()
     trading_mode.create_order.reset_mock()
 
+    orders = await modes_util.convert_asset_to_target_asset(
+        trading_mode, "USDT", "ETH", tickers, asset_amount=decimal.Decimal(1000)
+    )
+    assert len(orders) == 1
+    order = orders[0]
+    assert order.order_type == trading_enums.TraderOrderType.BUY_MARKET
+    assert order.symbol == "ETH/USDT"
+    assert order.origin_quantity == decimal.Decimal("0.66666666")
+    assert order.created_last_price == decimal.Decimal(1500)
+    trading_mode.create_order.assert_called_once()
+    trading_mode.create_order.reset_mock()
+
+    # with fees paid in quote
+    fees = {
+        trading_enums.FeePropertyColumns.COST.value: "2",
+        trading_enums.FeePropertyColumns.CURRENCY.value: "USDT",
+    }
+    with mock.patch.object(exchange_manager.exchange, "get_trade_fee", mock.Mock(return_value=fees)) \
+         as get_trade_fee_mock:
+        # cast 1: enough funds in pf to cover fees
+        orders = await modes_util.convert_asset_to_target_asset(
+            trading_mode, "USDT", "ETH", tickers, asset_amount=decimal.Decimal(450)
+        )
+        assert len(orders) == 1
+        order = orders[0]
+        assert order.order_type == trading_enums.TraderOrderType.BUY_MARKET
+        assert order.symbol == "ETH/USDT"
+        assert order.origin_quantity == decimal.Decimal("0.3")
+        assert order.created_last_price == decimal.Decimal(1500)
+        get_trade_fee_mock.assert_called_once()
+        get_trade_fee_mock.reset_mock()
+        trading_mode.create_order.assert_called_once()
+        trading_mode.create_order.reset_mock()
+
+        # cast 2: reduce amount to cover fees
+        orders = await modes_util.convert_asset_to_target_asset(
+            trading_mode, "USDT", "ETH", tickers, asset_amount=decimal.Decimal(1000)
+        )
+        assert len(orders) == 1
+        order = orders[0]
+        assert order.order_type == trading_enums.TraderOrderType.BUY_MARKET
+        assert order.symbol == "ETH/USDT"
+        assert order.origin_quantity == decimal.Decimal("0.66400000")   # lower than 0.66666666 when fees is 0 USDT
+        assert order.created_last_price == decimal.Decimal(1500)
+        get_trade_fee_mock.assert_called_once()
+        trading_mode.create_order.assert_called_once()
+        trading_mode.create_order.reset_mock()
+
 
 def _get_trading_mode(exchange_manager):
     return mock.Mock(

{OctoBot-Trading-2.4.57 → OctoBot-Trading-2.4.59}/tests/personal_data/orders/__init__.py

@@ -45,6 +45,16 @@ def created_order(order_type, order_type_enum, *args, **kwargs):
     return order
 
 
+
+@pytest.fixture()
+def backtesting_buy_and_sell_limit_orders(event_loop, backtesting_trader):
+    _, _, trader_instance = backtesting_trader
+    return (
+        created_order(BuyLimitOrder, TraderOrderType.BUY_LIMIT, trader_instance),
+        created_order(SellLimitOrder, TraderOrderType.SELL_LIMIT, trader_instance)
+    )
+
+
 @pytest.fixture()
 def buy_limit_order(event_loop, simulated_trader):
     _, _, trader_instance = simulated_trader

{OctoBot-Trading-2.4.57 → OctoBot-Trading-2.4.59}/tests/personal_data/orders/test_order.py

@@ -303,10 +303,16 @@ async def test_trigger_chained_orders(trader_simulator):
     await base_order.on_filled(True)
 
     # with chained orders
-    order_mock_1 = mock.Mock()
-    order_mock_1.should_be_created = mock.Mock(return_value=True)
-    order_mock_2 = mock.Mock()
-    order_mock_2.should_be_created = mock.Mock(return_value=False)
+    order_mock_1 = mock.Mock(
+        update_price_if_outdated=mock.AsyncMock(),
+        update_quantity_with_order_fees=mock.AsyncMock(return_value=True),
+        should_be_created=mock.Mock(return_value=True)
+    )
+    order_mock_2 = mock.Mock(
+        update_price_if_outdated=mock.AsyncMock(),
+        update_quantity_with_order_fees=mock.AsyncMock(return_value=True),
+        should_be_created=mock.Mock(return_value=False)
+    )
     with mock.patch.object(order_util, "create_as_chained_order", mock.AsyncMock()) as create_as_chained_order_mock:
 
         base_order.add_chained_order(order_mock_1)
@@ -316,12 +322,20 @@ async def test_trigger_chained_orders(trader_simulator):
         await base_order.on_filled(False)
         order_mock_1.should_be_created.assert_not_called()
         order_mock_2.should_be_created.assert_not_called()
+        order_mock_1.update_price_if_outdated.assert_not_called()
+        order_mock_2.update_price_if_outdated.assert_not_called()
+        order_mock_1.update_quantity_with_order_fees.assert_not_called()
+        order_mock_2.update_quantity_with_order_fees.assert_not_called()
         create_as_chained_order_mock.assert_not_called()
 
         # triggers chained orders
         await base_order.on_filled(True)
         order_mock_1.should_be_created.assert_called_once()
         order_mock_2.should_be_created.assert_called_once()
+        order_mock_1.update_price_if_outdated.assert_called_once()
+        order_mock_2.update_price_if_outdated.assert_called_once()
+        order_mock_1.update_quantity_with_order_fees.assert_called_once()
+        order_mock_2.update_quantity_with_order_fees.assert_called_once()
         create_as_chained_order_mock.assert_called_once_with(order_mock_1)
 
 

OctoBot-Trading-2.4.59/tests/personal_data/orders/types/limit/test_limit_order.py

@@ -0,0 +1,118 @@
+#  Drakkar-Software OctoBot-Trading
+#  Copyright (c) Drakkar-Software, All rights reserved.
+#
+#  This library is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 3.0 of the License, or (at your option) any later version.
+#
+#  This library is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with this library.
+import decimal
+import mock
+import pytest
+
+import octobot_trading.enums as enums
+
+import octobot_trading.constants as trading_constants
+import octobot_trading.personal_data as trading_personal_data
+from tests.personal_data import DEFAULT_MARKET_QUANTITY, DEFAULT_ORDER_SYMBOL
+from tests.test_utils.random_numbers import decimal_random_quantity
+
+from tests import event_loop
+from tests.exchanges import backtesting_trader, backtesting_config, backtesting_exchange_manager, fake_backtesting
+from tests.personal_data.orders import backtesting_buy_and_sell_limit_orders
+
+pytestmark = pytest.mark.asyncio
+
+
+async def test_update_price_if_outdated(backtesting_buy_and_sell_limit_orders):
+    buy_limit_order, sell_limit_order = backtesting_buy_and_sell_limit_orders
+    buy_order_price = decimal.Decimal("100")
+    buy_limit_order.update(
+        price=buy_order_price,
+        quantity=decimal_random_quantity(max_value=DEFAULT_MARKET_QUANTITY / buy_order_price),
+        symbol=DEFAULT_ORDER_SYMBOL,
+        order_type=enums.TraderOrderType.BUY_LIMIT,
+    )
+    sell_order_price = decimal.Decimal("150")
+    sell_limit_order.update(
+        price=sell_order_price,
+        quantity=decimal_random_quantity(max_value=DEFAULT_MARKET_QUANTITY / sell_order_price),
+        symbol=DEFAULT_ORDER_SYMBOL,
+        order_type=enums.TraderOrderType.BUY_LIMIT,
+    )
+    origin_update_limit_price_if_necessary = buy_limit_order._update_limit_price_if_necessary
+    # buy side
+    with mock.patch.object(
+        buy_limit_order, "_update_limit_price_if_necessary",
+        mock.Mock(side_effect=origin_update_limit_price_if_necessary)
+    ) as _update_limit_price_if_necessary_mock:
+        # without price
+        await buy_limit_order.update_price_if_outdated()
+        _update_limit_price_if_necessary_mock.assert_not_called()
+
+        # with up-to-date price
+        buy_limit_order.exchange_manager.exchange_symbols_data.get_exchange_symbol_data(buy_limit_order.symbol).\
+            prices_manager.set_mark_price(decimal.Decimal("110"), enums.MarkPriceSources.EXCHANGE_MARK_PRICE.value)
+        await buy_limit_order.update_price_if_outdated()
+        _update_limit_price_if_necessary_mock.assert_called_once()
+        assert buy_limit_order.origin_price is buy_order_price
+        _update_limit_price_if_necessary_mock.reset_mock()
+
+        # with outdated price
+        buy_limit_order.exchange_manager.exchange_symbols_data.get_exchange_symbol_data(buy_limit_order.symbol).\
+            prices_manager.set_mark_price(decimal.Decimal("90"), enums.MarkPriceSources.EXCHANGE_MARK_PRICE.value)
+        await buy_limit_order.update_price_if_outdated()
+
+        _update_limit_price_if_necessary_mock.assert_called_once()
+        # price got adapted
+        assert buy_limit_order.origin_price < buy_order_price
+        assert buy_limit_order.origin_price == decimal.Decimal("90") * (
+            trading_constants.ONE + trading_constants.CHAINED_ORDERS_OUTDATED_PRICE_ALLOWANCE
+        )
+
+    sell_limit_order.exchange_manager.exchange_symbols_data.get_exchange_symbol_data(sell_limit_order.symbol). \
+        prices_manager._reset_prices()
+    origin_update_limit_price_if_necessary = sell_limit_order._update_limit_price_if_necessary
+    # sell side
+    with mock.patch.object(
+        sell_limit_order, "_update_limit_price_if_necessary",
+        mock.Mock(side_effect=origin_update_limit_price_if_necessary)
+    ) as _update_limit_price_if_necessary_mock:
+        # without price
+        await sell_limit_order.update_price_if_outdated()
+        _update_limit_price_if_necessary_mock.assert_not_called()
+
+        # with up-to-date price
+        sell_limit_order.exchange_manager.exchange_symbols_data.get_exchange_symbol_data(sell_limit_order.symbol).\
+            prices_manager.set_mark_price(decimal.Decimal("110"), enums.MarkPriceSources.EXCHANGE_MARK_PRICE.value)
+        await sell_limit_order.update_price_if_outdated()
+        _update_limit_price_if_necessary_mock.assert_called_once()
+        assert sell_limit_order.origin_price is sell_order_price
+        _update_limit_price_if_necessary_mock.reset_mock()
+
+        # with outdated price
+        not_round_price = decimal.Decimal("155") + decimal.Decimal(1/3)  # force not round number
+        sell_limit_order.exchange_manager.exchange_symbols_data.get_exchange_symbol_data(sell_limit_order.symbol).\
+            prices_manager.set_mark_price(not_round_price, enums.MarkPriceSources.EXCHANGE_MARK_PRICE.value)
+        await sell_limit_order.update_price_if_outdated()
+
+        _update_limit_price_if_necessary_mock.assert_called_once()
+        # price got adapted
+        assert sell_limit_order.origin_price > sell_order_price
+        assert sell_limit_order.origin_price != not_round_price * (
+            trading_constants.ONE - trading_constants.CHAINED_ORDERS_OUTDATED_PRICE_ALLOWANCE
+        )
+        # ensure price decimals got adapted
+        assert sell_limit_order.origin_price == trading_personal_data.decimal_adapt_price(
+            sell_limit_order.exchange_manager.exchange.get_market_status(sell_limit_order.symbol, with_fixer=False),
+            not_round_price * (
+                trading_constants.ONE - trading_constants.CHAINED_ORDERS_OUTDATED_PRICE_ALLOWANCE
+            )
+        )