OctoBot-Trading 2.4.181__tar.gz → 2.4.183__tar.gz

{OctoBot-Trading-2.4.181 → OctoBot-Trading-2.4.183}/CHANGELOG.md

@@ -4,6 +4,16 @@ 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.183] - 2025-06-01
+### Fixed
+[Exchanges] fix edit_order
+
+## [2.4.182] - 2025-05-31
+### Updated
+[Exchanges] set hostname on custom domain
+### Fixed
+[States] fix deadlock
+
 ## [2.4.181] - 2025-05-28
 ### Fixed
 [Orders] fix adapt_order_quantity_because_fees order side issue

{OctoBot-Trading-2.4.181 → OctoBot-Trading-2.4.183/OctoBot_Trading.egg-info}/PKG-INFO

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

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

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

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

{OctoBot-Trading-2.4.181 → OctoBot-Trading-2.4.183}/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.181 → OctoBot-Trading-2.4.183}/octobot_trading/exchanges/connectors/ccxt/ccxt_client_util.py

@@ -394,10 +394,11 @@ def get_custom_domain_config(exchange_class):
         return {}
     if url_config := exchange_class().describe()[ccxt_enums.ExchangeColumns.URLS.value]:
         commons_logging.get_logger(__name__).info(
-            f"Using custom domain for {exchange_class.__name__}: {old} is replaced by {new}"
+            f"Using custom domain for {exchange_class.__name__}: {old} is replaced by {new}, hostname has been updated"
         )
         return {
-            ccxt_enums.ExchangeColumns.URLS.value: _get_patched_url_config(url_config, old, new)
+            ccxt_enums.ExchangeColumns.URLS.value: _get_patched_url_config(url_config, old, new),
+            ccxt_enums.ExchangeColumns.HOSTNAME.value: new
         }
     return {}
 

{OctoBot-Trading-2.4.181 → OctoBot-Trading-2.4.183}/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,17 +680,46 @@ 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)
+        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, 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
+            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
-        # do not use keyword arguments here as default ccxt edit order is passing *args (and not **kwargs)
-        return self.adapter.adapt_order(
-            await self.client.edit_order(
-                exchange_order_id, symbol, ccxt_order_type, side, quantity, price_to_use, params
-            ),
-            symbol=symbol, quantity=quantity
-        )
+            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:

{OctoBot-Trading-2.4.181 → OctoBot-Trading-2.4.183}/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"
@@ -120,6 +143,7 @@ class ExchangeWrapperLibs(enum.Enum):
 class ExchangeColumns(enum.Enum):
     WEBSITE = "www"
     URLS = "urls"
+    HOSTNAME = "hostname"
     API = "api"
     REST = "rest"
     WEBSOCKET = "ws"

{OctoBot-Trading-2.4.181 → OctoBot-Trading-2.4.183}/octobot_trading/exchanges/traders/trader.py

@@ -527,15 +527,26 @@ class Trader(util.Initializable):
                 f"it impossible to handle this the issue. Please report it if you see it. "
                 f"Order: {order}"
             ) from err
-        # trigger forced refresh to get an update of the order
         if order.state.is_refreshing():
-            await order.state.wait_for_next_state(cancelling_timeout)
+            # 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}")
+                return True
         else:
+            # trigger forced refresh to get an update of the order
             previous_status = order.status
             await order.state.synchronize(force_synchronization=True)
             if previous_status != order.status:
-                # status changed: wait for state change
-                await order.state.wait_for_next_state(cancelling_timeout)
+                # 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}")
+                    return True
         if order.is_cancelled():
             self.logger.debug(f"Tried to cancel an already cancelled order. Order: {order}")
             return True

{OctoBot-Trading-2.4.181 → OctoBot-Trading-2.4.183}/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
@@ -67,8 +68,8 @@ class RestExchange(abstract_exchange.AbstractExchange):
     # set True when get_positions() is not returning empty positions and should use get_position() instead
     REQUIRES_SYMBOL_FOR_EMPTY_POSITION = False
     SUPPORTS_SET_MARGIN_TYPE = True  # set False when there is no API to switch between cross and isolated margin types
-    SUPPORTS_SET_MARGIN_TYPE_ON_OPEN_POSITIONS = True  # set False when the exchange refuses to change margin type
-    # when an associated position is open
+    # set False when the exchange refuses to change margin type when an associated position is open
+    SUPPORTS_SET_MARGIN_TYPE_ON_OPEN_POSITIONS = 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
@@ -79,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)
@@ -199,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(
@@ -216,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)
@@ -1024,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.181 → OctoBot-Trading-2.4.183}/octobot_trading/modes/abstract_trading_mode.py

@@ -564,10 +564,11 @@ class AbstractTradingMode(abstract_tentacle.AbstractTentacle):
             wait_for_creation=wait_for_creation, creation_timeout=creation_timeout
         )
 
-    async def cancel_order(self, order, ignored_order: object = None) -> bool:
+    async def cancel_order(self, order, ignored_order: object = None, wait_for_cancelling: bool = True) -> bool:
         return await signals.cancel_order(
             self.exchange_manager, self.should_emit_trading_signal(), order,
-            ignored_order=ignored_order
+            ignored_order=ignored_order,
+            wait_for_cancelling=wait_for_cancelling
         )
 
     async def cancel_all_orders(

{OctoBot-Trading-2.4.181 → OctoBot-Trading-2.4.183}/octobot_trading/personal_data/orders/order.py

@@ -368,13 +368,13 @@ class Order(util.Initializable):
     def get_total_fees(self, currency):
         return order_util.get_fees_for_currency(self.fee, currency)
 
-    def is_created(self):
+    def is_created(self) -> bool:
         return self.state is None or self.state.is_created()
 
-    def is_pending_creation(self):
+    def is_pending_creation(self) -> bool:
         return isinstance(self.state, orders_states.PendingCreationOrderState)
 
-    def is_open(self):
+    def is_open(self) -> bool:
         # also check is_initialized to avoid considering uncreated orders as open
         return (
             self.state is None or self.state.is_open() or (
@@ -382,30 +382,39 @@ class Order(util.Initializable):
             )
         )
 
-    def is_filled(self):
+    def is_filled(self) -> bool:
         if self.state is None:
             return self.status is enums.OrderStatus.FILLED
         return self.state.is_filled() or (self.state.is_closed() and self.status is enums.OrderStatus.FILLED)
 
-    def is_cancelled(self):
+    def is_cancelled(self) -> bool:
         if self.state is None:
             return self.status is enums.OrderStatus.CANCELED
         return self.state.is_canceled() or (self.state.is_closed() and self.status is enums.OrderStatus.CANCELED)
 
-    def is_cancelling(self):
+    def is_cancelling(self) -> bool:
         if self.state is None:
             return self.status is enums.OrderStatus.PENDING_CANCEL
         return self.state.state is enums.OrderStates.CANCELING or self.status is enums.OrderStatus.PENDING_CANCEL
 
-    def is_closed(self):
+    def is_closed(self) -> bool:
         if self.state is None:
             return self.status is enums.OrderStatus.CLOSED
         return self.state.is_closed() if self.state is not None else self.status is enums.OrderStatus.CLOSED
 
-    def is_refreshing(self):
+    def is_refreshing(self) -> bool:
         return self.state is not None and self.state.is_refreshing()
 
-    def can_be_edited(self):
+    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_refreshing_state(self, state_type) -> bool:
+        return self.is_refreshing() 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())