OctoBot-Trading 2.4.182__tar.gz → 2.4.184__tar.gz

{OctoBot-Trading-2.4.182 → OctoBot-Trading-2.4.184}/CHANGELOG.md

@@ -4,6 +4,14 @@ 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.184] - 2025-06-04
+### Fixed
+[Order Cancel] fix deadlock
+
+## [2.4.183] - 2025-06-01
+### Fixed
+[Exchanges] fix edit_order
+
 ## [2.4.182] - 2025-05-31
 ### Updated
 [Exchanges] set hostname on custom domain

{OctoBot-Trading-2.4.182 → OctoBot-Trading-2.4.184/OctoBot_Trading.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: OctoBot-Trading
-Version: 2.4.182
+Version: 2.4.184
 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.182](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
+# OctoBot-Trading [2.4.184](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.182/OctoBot_Trading.egg-info → OctoBot-Trading-2.4.184}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: OctoBot-Trading
-Version: 2.4.182
+Version: 2.4.184
 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.182](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
+# OctoBot-Trading [2.4.184](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.182 → OctoBot-Trading-2.4.184}/README.md

@@ -1,4 +1,4 @@
-# OctoBot-Trading [2.4.182](https://github.com/Drakkar-Software/OctoBot-Trading/blob/master/CHANGELOG.md)
+# OctoBot-Trading [2.4.184](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.182 → OctoBot-Trading-2.4.184}/octobot_trading/__init__.py

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

{OctoBot-Trading-2.4.182 → OctoBot-Trading-2.4.184}/octobot_trading/exchange_data/recent_trades/channel/recent_trade_updater.py

@@ -34,6 +34,7 @@ class RecentTradeUpdater(recent_trade_channel.RecentTradeProducer):
         self.refresh_time = RecentTradeUpdater.RECENT_TRADE_REFRESH_TIME
 
     async def init_recent_trades(self):
+        pair = None
         try:
             for pair in self.channel.exchange_manager.exchange_config.traded_symbol_pairs:
                 recent_trades = await self.channel.exchange_manager.exchange.\
@@ -45,7 +46,7 @@ class RecentTradeUpdater(recent_trade_channel.RecentTradeProducer):
             self.logger.exception(
                 e,
                 True,
-                f"Fail to initialize recent trades : {html_util.get_html_summary_if_relevant(e)}"
+                f"Fail to initialize {pair} recent trades : {html_util.get_html_summary_if_relevant(e)}"
             )
 
     async def start(self):

{OctoBot-Trading-2.4.182 → OctoBot-Trading-2.4.184}/octobot_trading/exchanges/adapters/abstract_adapter.py

@@ -148,8 +148,9 @@ class AbstractAdapter:
 
     def fix_order(self, raw, **kwargs):
         # id is reserved for octobot managed id. store exchange id in EXCHANGE_ID
-        raw[enums.ExchangeConstantsOrderColumns.EXCHANGE_ID.value] = \
-            raw.pop(enums.ExchangeConstantsOrderColumns.ID.value, None)
+        if enums.ExchangeConstantsOrderColumns.ID.value in raw:
+            raw[enums.ExchangeConstantsOrderColumns.EXCHANGE_ID.value] = \
+                raw.pop(enums.ExchangeConstantsOrderColumns.ID.value, None)
         # add generic logic if necessary
         return raw
 

{OctoBot-Trading-2.4.182 → OctoBot-Trading-2.4.184}/octobot_trading/exchanges/connectors/ccxt/ccxt_connector.py

@@ -22,6 +22,7 @@ import aiohttp_socks
 import typing
 import inspect
 import binascii
+import copy
 
 import octobot_commons.enums
 import octobot_commons.logging
@@ -596,52 +597,67 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
             symbol=symbol, quantity=quantity
         )
 
+    def _add_stop_loss_price_param(self, params: dict, price: float):
+        params = params or {}
+        if ccxt_enums.ExchangeOrderCCXTUnifiedParams.STOP_LOSS_PRICE.value not in params:
+            params[ccxt_enums.ExchangeOrderCCXTUnifiedParams.STOP_LOSS_PRICE.value] = price
+        return params
+
+    def _add_edit_stop_loss_price_param(self, params: dict, price: float):
+        params = params or {}
+        if self.exchange_manager.exchange.STOP_LOSS_EDIT_PRICE_PARAM not in params:
+            params[self.exchange_manager.exchange.STOP_LOSS_EDIT_PRICE_PARAM] = price
+        return params
+
     @ccxt_client_util.converted_ccxt_common_errors
     async def create_market_stop_loss_order(self, symbol, quantity, price, side, current_price, params=None) -> dict:
-        if self.client.has.get("createStopMarketOrder"):
-            try:
-                return self.adapter.adapt_order(
-                    await self.client.createStopMarketOrder(
-                        symbol,
-                        side=side,
-                        amount=quantity,
-                        stopPrice=price,
-                        params=params,
-                    ),
-                    symbol=symbol, quantity=quantity
-                )
-            except ccxt.OrderImmediatelyFillable:
-                # make sure stop always stops
-                created_order = await self.exchange_manager.exchange.create_order(
-                    order_type=(enums.TraderOrderType.BUY_MARKET
-                                if side == enums.TradeOrderSide.BUY.value
-                                else enums.TraderOrderType.SELL_MARKET),
-                    symbol=symbol,
-                    quantity=decimal.Decimal(str(quantity)),
-                    price=decimal.Decimal(str(price)),
-                    current_price=decimal.Decimal(str(current_price))
+        try:
+            params = self._add_stop_loss_price_param(params, price)
+            return self.adapter.adapt_order(
+                await self.client.create_order(
+                    symbol,
+                    enums.TradeOrderType.MARKET.value,
+                    side,
+                    quantity,
+                    params=params,
+                ),
+                symbol=symbol, quantity=quantity
+            )
+        except ccxt.NotSupported as err:
+            raise NotImplementedError(f"create_market_stop_loss_order is not supported {err}")
+        except ccxt.OrderImmediatelyFillable:
+            # make sure stop always stops
+            created_order = await self.exchange_manager.exchange.create_order(
+                order_type=(enums.TraderOrderType.BUY_MARKET
+                            if side == enums.TradeOrderSide.BUY.value
+                            else enums.TraderOrderType.SELL_MARKET),
+                symbol=symbol,
+                quantity=decimal.Decimal(str(quantity)),
+                price=decimal.Decimal(str(price)),
+                current_price=decimal.Decimal(str(current_price))
+            )
+            created_order[enums.ExchangeConstantsOrderColumns.TYPE.value] = (
+                enums.TraderOrderType.STOP_LOSS.value
                 )
-                created_order[enums.ExchangeConstantsOrderColumns.TYPE.value] = (
-                    enums.TraderOrderType.STOP_LOSS.value
-                    )
-                return created_order
-        raise NotImplementedError("create_market_stop_loss_order is not implemented")
+            return created_order
 
     @ccxt_client_util.converted_ccxt_common_errors
     async def create_limit_stop_loss_order(self, symbol, quantity, price, stop_price, side, params=None) -> dict:
-        if self.client.has.get("createStopLimitOrder"):
+        try:
+            params = self._add_stop_loss_price_param(params, stop_price)
             return self.adapter.adapt_order(
-                await self.client.create_stop_limit_order(
+                await self.client.create_order(
                     symbol,
-                    side=side,
-                    amount=quantity,
+                    enums.TradeOrderType.LIMIT.value,
+                    side,
+                    quantity,
                     price=price,
-                    stopPrice=stop_price,
                     params=params,
                 ),
                 symbol=symbol, quantity=quantity
             )
-        raise NotImplementedError("create_limit_stop_loss_order is not implemented")
+        except ccxt.NotSupported as err:
+            raise NotImplementedError(f"create_limit_stop_loss_order is not supported {err}")
 
     @ccxt_client_util.converted_ccxt_common_errors
     async def create_market_take_profit_order(self, symbol, quantity, price=None, side=None, params=None) -> dict:
@@ -664,21 +680,47 @@ class CCXTConnector(abstract_exchange.AbstractExchange):
                          quantity: float, price: float, stop_price: float = None, side: str = None,
                          current_price: float = None, params: dict = None):
         ccxt_order_type = self.get_ccxt_order_type(order_type)
-        price_to_use = price
-        if ccxt_order_type == enums.TradeOrderType.MARKET.value:
-            # can't set price in market orders
-            price_to_use = None
-        # do not use keyword arguments here as default ccxt edit order is passing *args (and not **kwargs)
-        if self.exchange_manager.exchange.SUPPORTS_NATIVE_EDIT_ORDER:
+        local_params = copy.copy(params)
+        if order_type == enums.TraderOrderType.STOP_LOSS:
+            local_params = self._add_edit_stop_loss_price_param(local_params, stop_price or price)
+        elif order_type == enums.TraderOrderType.STOP_LOSS_LIMIT:
+            local_params = self._add_edit_stop_loss_price_param(local_params, stop_price)
+        if self.exchange_manager.exchange.supports_native_edit_order(order_type):
+            price_to_use = price
+            if ccxt_order_type == enums.TradeOrderType.MARKET.value:
+                # can't set price in market orders
+                price_to_use = None
             edited_order = await self.client.edit_order(
-                exchange_order_id, symbol, ccxt_order_type, side, quantity, price_to_use, params
+                exchange_order_id, symbol, ccxt_order_type, side, quantity, price_to_use, local_params
             )
+            if edited_order is not None:
+                # sometimes exchanges don't return the edited order details (ex: coinbase)
+                # => fill it with what we know and verify_order will fetch the rest
+                if not edited_order.get(ecoc.ID.value):
+                    edited_order[ecoc.ID.value] = exchange_order_id
+                if not edited_order.get(ecoc.SYMBOL.value):
+                    edited_order[ecoc.SYMBOL.value] = symbol
         else:
             # ccxt exchange edit order is disabled: force ccxt.exchange default edit order behavior
-            await self.client.cancel_order(exchange_order_id, symbol)
-            edited_order = await self.client.create_order(symbol, ccxt_order_type, side, quantity, price_to_use, params)
+            edited_order = await self._edit_order_by_cancel_and_create(
+                exchange_order_id, symbol, order_type, side, quantity, price, params
+            )
         return self.adapter.adapt_order(edited_order, symbol=symbol, quantity=quantity)
 
+    async def _edit_order_by_cancel_and_create(
+        self, exchange_order_id: str, symbol: str, order_type: enums.TraderOrderType,
+        side: str, quantity: float, price: float, params: dict
+    ) -> dict:
+        await self.client.cancel_order(exchange_order_id, symbol)
+        price_to_use = price
+        local_params = copy.copy(params)
+        ccxt_order_type = self.get_ccxt_order_type(order_type)
+        if ccxt_order_type == enums.TradeOrderType.MARKET.value:
+            # can't set price in market orders
+            price_to_use = None
+            local_params = self._add_stop_loss_price_param(local_params, price)
+        return await self.client.create_order(symbol, ccxt_order_type, side, quantity, price_to_use, local_params)
+
     @ccxt_client_util.converted_ccxt_common_errors
     async def cancel_all_orders(self, symbol: str = None, **kwargs: dict) -> None:
         try:

{OctoBot-Trading-2.4.182 → OctoBot-Trading-2.4.184}/octobot_trading/exchanges/connectors/ccxt/enums.py

@@ -112,6 +112,29 @@ class ExchangeOrderCCXTColumns(enum.Enum):
     MARGIN_MODE = "marginMode"
 
 
+class ExchangeOrderCCXTUnifiedParams(enum.Enum):
+    # see https://docs.ccxt.com/ for details
+    REDUCE_ONLY = "reduceOnly"  # bool
+
+    # when creating orders
+    STOP_LOSS_PRICE = "stopLossPrice" # float
+    TAKE_PROFIT_PRICE = "takeProfitPrice" # float
+
+    # when editing orders
+    STOP_PRICE = "stopPrice"    # float
+
+    # for trigger orders
+    TRIGGER_DIRECTION = "triggerDirection"    # ascending/descending
+    TRIGGER_PRICE = "triggerPrice"    # float
+    STOP_LOSS = "stopLoss"    # dict with price and triggerPrice
+    TAKE_PROFIT = "takeProfit"  # dict with  price and triggerPrice
+
+    # for trailing orders
+    TRAILING_PERCENT = "trailingPercent" # float [0:100]
+    TRAILING_AMOUNT = "trailingAmount"  # float
+    TRAILING_TRIGGER_PRICE = "trailingTriggerPrice"    # float
+
+
 class ExchangeWrapperLibs(enum.Enum):
     ASYNC_CCXT = "async_ccxt"
     CCXT = "ccxt"

{OctoBot-Trading-2.4.182 → OctoBot-Trading-2.4.184}/octobot_trading/exchanges/traders/trader.py

@@ -465,6 +465,7 @@ class Trader(util.Initializable):
             order.is_waiting_for_chained_trigger = False
             return success
         order_status = None
+        is_order_refreshing = False
         # if real order: cancel on exchange
         if not self.simulate and order.is_active and not order.is_self_managed():
             try:
@@ -496,6 +497,7 @@ class Trader(util.Initializable):
             except Exception as err:
                 self.logger.exception(err, True, f"Failed to cancel order {order}")
                 return False
+            is_order_refreshing = order.is_refreshing()
             if order_status is enums.OrderStatus.CANCELED:
                 order.status = octobot_trading.enums.OrderStatus.CANCELED
                 self.logger.debug(f"Successfully cancelled order {order}")
@@ -505,11 +507,14 @@ class Trader(util.Initializable):
         else:
             order.status = octobot_trading.enums.OrderStatus.CANCELED
 
-        await order.on_cancel(force_cancel=order.status is octobot_trading.enums.OrderStatus.CANCELED,
-                              is_from_exchange_data=False,
-                              ignored_order=ignored_order)
-        if wait_for_cancelling and order.state is not None and order.state.is_pending():
-            await self._wait_for_order_cancel(order, cancelling_timeout)
+        if not is_order_refreshing:
+            # don't override state if order is already refreshing (most likely from open orders updater)
+            await order.on_cancel(force_cancel=order.status is octobot_trading.enums.OrderStatus.CANCELED,
+                                  is_from_exchange_data=False,
+                                  ignored_order=ignored_order)
+        if wait_for_cancelling and (order.is_refreshing() or order.is_pending()):
+            # Don't wait for new state to avoid potential deadlock. Will raise if cancel is not in process
+            self._ensure_probably_canceled_order(order, None)
         return True
 
     async def _handle_order_cancel_error(self, order, err, wait_for_cancelling, cancelling_timeout):
@@ -531,10 +536,7 @@ class Trader(util.Initializable):
             # can't wait for the order state to fully refresh as it will require a portfolio lock which might
             # be locked by this ask already (and create a deadlock)
             # => be optimistic and consider refreshing state as end state
-            if order.is_refreshing_filling_state():
-                raise errors.FilledOrderError(f"Order is filled, it can't be cancelled. Order: {order}") from err
-            if order.is_refreshing_canceling_state():
-                self.logger.debug(f"Tried to cancel an already cancelled order. Order: {order}")
+            if self._ensure_probably_canceled_order(order, err):
                 return True
         else:
             # trigger forced refresh to get an update of the order
@@ -542,17 +544,14 @@ class Trader(util.Initializable):
             await order.state.synchronize(force_synchronization=True)
             if previous_status != order.status:
                 # don't wait for new state to avoid potential deadlock
-                if order.is_refreshing_filling_state():
-                    raise errors.FilledOrderError(f"Order is filled, it can't be cancelled. Order: {order}") from err
-                if order.is_refreshing_canceling_state():
-                    self.logger.debug(f"Tried to cancel an already cancelled order. Order: {order}")
+                if self._ensure_probably_canceled_order(order, err):
                     return True
         if order.is_cancelled():
             self.logger.debug(f"Tried to cancel an already cancelled order. Order: {order}")
             return True
         if order.is_cancelling():
-            if wait_for_cancelling:
-                await self._wait_for_order_cancel(order, cancelling_timeout)
+            # don't wait for new state to avoid potential deadlock, just check that order is not filling
+            self._ensure_probably_canceled_order(order, err)
             return True
         elif order.is_open():
             if isinstance(err, errors.OrderNotFoundOnCancelError):
@@ -574,6 +573,20 @@ class Trader(util.Initializable):
                 f"Can't cancel order and unknown post sync order state for order: {order}."
             ) from err
 
+    def _ensure_probably_canceled_order(self, order, err: typing.Optional[Exception]) -> bool:
+        if order.is_refreshing_filling_state():
+            filled_err = errors.FilledOrderError(f"Order is filled, it can't be cancelled. Order: {order}")
+            if err is None:
+                raise filled_err
+            raise filled_err from err
+        if order.is_refreshing_canceling_state():
+            self.logger.debug(f"Tried to cancel an already cancelled order. Order: {order}")
+            return True
+        if order.is_pending_cancel_state():
+            self.logger.debug(f"Tried to cancel a pending cancel order. Order: {order}")
+            return True
+        return False
+
     async def cancel_all_orders(
         self,
         symbol: str,

{OctoBot-Trading-2.4.182 → OctoBot-Trading-2.4.184}/octobot_trading/exchanges/types/rest_exchange.py

@@ -34,6 +34,7 @@ import octobot_trading.constants as constants
 import octobot_trading.errors as errors
 import octobot_trading.exchanges.util as exchanges_util
 import octobot_trading.exchanges.connectors.ccxt.ccxt_connector as ccxt_connector
+import octobot_trading.exchanges.connectors.ccxt.enums as ccxt_enums
 from octobot_trading.enums import ExchangeConstantsOrderColumns as ecoc
 import octobot_trading.exchanges.abstract_exchange as abstract_exchange
 import octobot_trading.exchange_data.contracts as contracts
@@ -69,8 +70,6 @@ class RestExchange(abstract_exchange.AbstractExchange):
     SUPPORTS_SET_MARGIN_TYPE = True  # set False when there is no API to switch between cross and isolated margin types
     # set False when the exchange refuses to change margin type when an associated position is open
     SUPPORTS_SET_MARGIN_TYPE_ON_OPEN_POSITIONS = True
-    # set False when default edit_order can't be used and order should always be canceled and recreated instead
-    SUPPORTS_NATIVE_EDIT_ORDER = True
     EXPECT_POSSIBLE_ORDER_NOT_FOUND_DURING_ORDER_CREATION = False  # set True when get_order() can return None
     # (order not found) when orders are being created on exchange and are not fully processed on the exchange side.
     REQUIRES_AUTHENTICATION = False  # set True when even normally public apis require authentication
@@ -81,6 +80,8 @@ class RestExchange(abstract_exchange.AbstractExchange):
     IS_SKIPPING_EMPTY_CANDLES_IN_OHLCV_FETCH = False    # set True when the exchange is known for not returning any
     # candle when no traded happened during a candle time frame. In this case, a missing candle in backtesting won't
     # trigger an error
+    # Name of the price param to give ccxt to edit a stop loss
+    STOP_LOSS_EDIT_PRICE_PARAM = ccxt_enums.ExchangeOrderCCXTUnifiedParams.STOP_LOSS_PRICE.value
     """
     RestExchange is using its exchange connector to interact with the exchange.
     It should be used regardless of the exchange or the exchange library (ccxt or other)
@@ -201,6 +202,9 @@ class RestExchange(abstract_exchange.AbstractExchange):
                            price: decimal.Decimal = None, stop_price: decimal.Decimal = None,
                            side: enums.TradeOrderSide = None, current_price: decimal.Decimal = None,
                            reduce_only: bool = False, params: dict = None) -> typing.Optional[dict]:
+        if self.exchange_manager.is_future:
+            # on futures exchange expects, quantity in contracts: convert quantity into contracts
+            quantity = quantity / self.get_contract_size(symbol)
         async with self._order_operation(order_type, symbol, quantity, price, stop_price):
             with self.creating_order(side, symbol, quantity, price):
                 created_order = await self._create_order_with_retry(
@@ -218,6 +222,9 @@ class RestExchange(abstract_exchange.AbstractExchange):
                          params: dict = None):
         # Note: on most exchange, this implementation will just replace the order by cancelling the one
         # which id is given and create a new one
+        if self.exchange_manager.is_future:
+            # on futures exchange expects, quantity in contracts: convert quantity into contracts
+            quantity = quantity / self.get_contract_size(symbol)
         async with self._order_operation(order_type, symbol, quantity, price, stop_price):
             float_quantity = float(quantity)
             float_price = float(price)
@@ -1026,6 +1033,10 @@ class RestExchange(abstract_exchange.AbstractExchange):
     def supports_trading_type(self, symbol, trading_type: enums.FutureContractType):
         return self.connector.supports_trading_type(symbol, trading_type)
 
+    def supports_native_edit_order(self, order_type: enums.TraderOrderType) -> bool:
+        # return False when default edit_order can't be used and order should always be canceled and recreated instead
+        return True
+
     def is_linear_symbol(self, symbol):
         """
         :param symbol: the symbol

{OctoBot-Trading-2.4.182 → OctoBot-Trading-2.4.184}/octobot_trading/personal_data/orders/channel/orders.py

@@ -29,7 +29,7 @@ class OrdersProducer(exchanges_channel.ExchangeChannelProducer):
 
     async def perform(self, orders, is_from_bot=False, are_closed=False):
         try:
-            self.logger.debug(f"Received order update for {len(orders)} {'closed' if are_closed else ''} orders.")
+            self.logger.debug(f"Received order update for {len(orders)}{' closed' if are_closed else ''} orders.")
             has_new_order = False
             waiting_complete_init_orders = []
             symbols = set()

{OctoBot-Trading-2.4.182 → OctoBot-Trading-2.4.184}/octobot_trading/personal_data/orders/channel/orders_updater.py

@@ -200,10 +200,10 @@ class OrdersUpdater(orders_channel.OrdersProducer):
 
         if raw_order is not None:
             self.logger.info(f"Received update for {order} on {exchange_name}: {raw_order}")
-
             await self.channel.exchange_manager.exchange_personal_data.handle_order_update_from_raw(
                 order.exchange_order_id, raw_order, should_notify=should_notify
             )
+            self.logger.info(f"Completed update for {order} on {exchange_name}")
         else:
             self.logger.info(f"Can't received update for {order} on {exchange_name}: received order is None")
 

{OctoBot-Trading-2.4.182 → OctoBot-Trading-2.4.184}/octobot_trading/personal_data/orders/order.py

@@ -405,15 +405,24 @@ class Order(util.Initializable):
     def is_refreshing(self) -> bool:
         return self.state is not None and self.state.is_refreshing()
 
+    def is_pending(self) -> bool:
+        return self.state is not None and self.state.is_pending()
+
     def is_refreshing_filling_state(self) -> bool:
         return self._is_refreshing_state(orders_states.FillOrderState)
 
     def is_refreshing_canceling_state(self) -> bool:
         return self._is_refreshing_state(orders_states.CancelOrderState)
 
+    def is_pending_cancel_state(self) -> bool:
+        return self._is_pending_state(orders_states.CancelOrderState)
+
     def _is_refreshing_state(self, state_type) -> bool:
         return self.is_refreshing() and isinstance(self.state, state_type)
 
+    def _is_pending_state(self, state_type) -> bool:
+        return self.is_pending() and isinstance(self.state, state_type)
+
     def can_be_edited(self) -> bool:
         # orders that are not yet open or already open can be edited
         return self.state is None or (self.state.is_open() and not self.is_refreshing())