[CCXT] update to 4.5.28

Author: GuillaumeDSM

octobot_trading/exchanges/types/rest_exchange.py

@@ -370,9 +370,12 @@ async def _verify_order(self, created_order, order_type, symbol, price, quantity
                 if order_exchange_id is None:
                     self.logger.error(f"No order exchange id on created order: {created_order}")
                     return None
-                params = get_order_params or {}
+                exchange_order_id = created_order[ecoc.EXCHANGE_ID.value]
+                params = self._order_request_kwargs_factory(
+                    exchange_order_id, order_type, **(get_order_params or {})
+                )
                 fetched_order = await self.get_order(
-                    created_order[ecoc.EXCHANGE_ID.value], symbol=symbol, **params
+                    exchange_order_id, symbol=symbol, **params
                 )
                 if fetched_order is None:
                     created_order[ecoc.STATUS.value] = enums.OrderStatus.PENDING_CREATION.value
@@ -688,9 +691,25 @@ async def get_price_ticker(self, symbol: str, **kwargs: dict) -> typing.Optional
     async def get_all_currencies_price_ticker(self, **kwargs: dict) -> typing.Optional[dict[str, dict]]:
         return await self.connector.get_all_currencies_price_ticker(**kwargs)
 
-    async def get_order(self, exchange_order_id: str, symbol: str = None, **kwargs: dict) -> dict:
+    def _order_request_kwargs_factory(
+        self, 
+        exchange_order_id: str, 
+        order_type: typing.Optional[enums.TraderOrderType] = None, 
+        **kwargs
+    ) -> dict:
+        # implement if the exchange needs additional kwargs to fetch an order, like to fetch stop orders
+        return kwargs
+
+    async def get_order(
+        self,
+        exchange_order_id: str,
+        symbol: typing.Optional[str] = None,
+        order_type: typing.Optional[enums.TraderOrderType] = None,
+        **kwargs: dict
+    ) -> dict:
+        extended_kwargs = self._order_request_kwargs_factory(exchange_order_id, order_type, **(kwargs or {}))
         return await self._ensure_order_completeness(
-            await self.connector.get_order(exchange_order_id, symbol=symbol, **kwargs),
+            await self.connector.get_order(exchange_order_id, symbol=symbol, **extended_kwargs),
             symbol, **kwargs
         )
 
@@ -806,7 +825,8 @@ async def cancel_all_orders(self, symbol: str = None, **kwargs: dict) -> None:
     async def cancel_order(
         self, exchange_order_id: str, symbol: str, order_type: enums.TraderOrderType, **kwargs: dict
     ) -> enums.OrderStatus:
-        return await self.connector.cancel_order(exchange_order_id, symbol, order_type, **kwargs)
+        extended_kwargs = self._order_request_kwargs_factory(exchange_order_id, order_type, **(kwargs or {}))
+        return await self.connector.cancel_order(exchange_order_id, symbol, order_type, **extended_kwargs)
 
     def get_trade_fee(self, symbol: str, order_type: enums.TraderOrderType, quantity, price, taker_or_maker) -> dict:
         return self.connector.get_trade_fee(symbol, order_type, quantity, price, taker_or_maker)

octobot_trading/personal_data/orders/channel/orders_updater.py

@@ -196,7 +196,9 @@ async def _order_fetch_and_push(self, order, should_notify=False):
         """
         exchange_name = self.channel.exchange_manager.exchange_name
         self.logger.info(f"Requested update for {order} on {exchange_name}")
-        raw_order = await self.channel.exchange_manager.exchange.get_order(order.exchange_order_id, order.symbol)
+        raw_order = await self.channel.exchange_manager.exchange.get_order(
+            order.exchange_order_id, order.symbol, order_type=order.order_type
+        )
 
         if raw_order is not None:
             self.logger.info(f"Received update for {order} on {exchange_name}: {raw_order}")

octobot_trading/personal_data/orders/order.py

@@ -857,7 +857,9 @@ def get_profitability(self):
         return self.order_profitability
 
     async def default_exchange_update_order_status(self):
-        raw_order = await self.exchange_manager.exchange.get_order(self.exchange_order_id, self.symbol)
+        raw_order = await self.exchange_manager.exchange.get_order(
+            self.exchange_order_id, self.symbol, order_type=self.order_type
+        )
         new_status = order_util.parse_order_status(raw_order)
         self.is_synchronized_with_exchange = True
         if new_status in {enums.OrderStatus.FILLED, enums.OrderStatus.CLOSED}:

octobot_trading/util/test_tools/exchanges_test_tools.py

@@ -267,8 +267,11 @@ async def get_order(
     exchange_manager,
     exchange_order_id: str,
     symbol: str,
+    order_type: enums.TraderOrderType,
 ) -> typing.Optional[dict]:
-    return await exchange_manager.exchange.get_order(exchange_order_id, symbol=symbol)
+    return await exchange_manager.exchange.get_order(
+        exchange_order_id, symbol=symbol, order_type=order_type
+    )
 
 
 @exchanges.retried_failed_network_request(
@@ -402,7 +405,9 @@ async def wait_for_other_status(order: personal_data.Order, timeout) -> personal
     iterations = 0
     origin_status = order.status.value
     while time.time() - t0 < timeout:
-        raw_order = await order.exchange_manager.exchange.get_order(order.exchange_order_id, order.symbol)
+        raw_order = await order.exchange_manager.exchange.get_order(
+            order.exchange_order_id, order.symbol, order_type=order.order_type
+        )
         iterations += 1
         if raw_order is not None and raw_order[enums.ExchangeConstantsOrderColumns.STATUS.value] != origin_status:
             logging.get_logger(order.get_logger_name()).info(

requirements.txt

@@ -8,7 +8,7 @@ OctoBot-Tentacles-Manager>=2.9, <2.10
 trading-backend>=1.2.35
 
 # Exchange connection requirements
-ccxt==4.5.22 # always ensure real exchanges tests (in tests_additional and authenticated exchange tests) are passing before changing the ccxt version
+ccxt==4.5.28 # always ensure real exchanges tests (in tests_additional and authenticated exchange tests) are passing before changing the ccxt version
 
 cryptography # Never specify a version (managed by https://github.com/Drakkar-Software/OctoBot-PyPi-Linux-Deployer)
 

tests_additional/real_exchanges/__init__.py

@@ -16,6 +16,7 @@
 import contextlib
 import dotenv
 import os
+import mock
 
 import octobot_commons.constants as commons_constants
 import octobot_commons.asyncio_tools as asyncio_tools
@@ -24,13 +25,14 @@
 import octobot_trading.exchanges as exchanges
 import octobot_trading.enums as enums
 import octobot_trading.errors as errors
+import octobot_trading.exchanges.util.exchange_util
 
 
 LOADED_EXCHANGE_CREDS_ENV_VARIABLES = False
 
 
 @contextlib.asynccontextmanager
-async def get_exchange_manager(exchange_name, config=None, authenticated=False, market_filter=None):
+async def get_exchange_manager(exchange_name, config=None, authenticated=False, market_filter=None, uses_tentacle=False):
     config = {**test_config.load_test_config(), **config} if config else test_config.load_test_config()
     if exchange_name not in config[commons_constants.CONFIG_EXCHANGES]:
         config[commons_constants.CONFIG_EXCHANGES][exchange_name] = {}
@@ -43,7 +45,18 @@ async def get_exchange_manager(exchange_name, config=None, authenticated=False,
     if config[commons_constants.CONFIG_EXCHANGES][exchange_name]. \
        get(commons_constants.CONFIG_EXCHANGE_TYPE, enums.ExchangeTypes.SPOT.value) == enums.ExchangeTypes.FUTURE.value:
         exchange_manager_instance.is_future = True
-    await exchange_manager_instance.initialize(exchange_config_by_exchange=None)
+    if not uses_tentacle:
+        # don't use exchange specific tentacles, even if they are available
+        with mock.patch.object(
+            octobot_trading.exchanges.util.exchange_util, 
+            "search_exchange_class_from_exchange_name", 
+            mock.Mock(return_value=exchanges.DefaultRestExchange)
+        ) as search_exchange_class_from_exchange_name_mock:
+            await exchange_manager_instance.initialize(exchange_config_by_exchange=None)
+            assert search_exchange_class_from_exchange_name_mock.call_count > 0
+    else:
+        # allow the use of exchange specific tentacles
+        await exchange_manager_instance.initialize(exchange_config_by_exchange=None)
     try:
         yield exchange_manager_instance
     except errors.UnreachableExchange as err:

tests_additional/real_exchanges/real_exchange_tester.py

@@ -19,7 +19,7 @@
 
 import pytest
 from ccxt import Exchange
-
+import ccxt
 import octobot_commons.constants as constants
 import octobot_commons.enums as commons_enums
 import octobot_trading.enums as trading_enums
@@ -49,6 +49,7 @@ class RealExchangeTester:
     HISTORICAL_CANDLES_TO_FETCH_COUNT = 650
     DEFAULT_CUSTOM_BOOK_LIMIT = 50
     ORDER_BOOK_DESYNC_ALLOWANCE = 60    # allow 60s desync
+    USES_TENTACLE = False  # set True when an exchange tentacles should be used in this test
 
     # Public methods: to be implemented as tests
     # Use await self._[method_name] to get the test request result
@@ -135,7 +136,7 @@ async def test_get_historical_ohlcv(self):
             self.HISTORICAL_CANDLES_TO_FETCH_COUNT * 0.85
             < len(historical_ohlcv)
             <= self.HISTORICAL_CANDLES_TO_FETCH_COUNT
-        )
+        ), f"{len(historical_ohlcv)=} not in [{self.HISTORICAL_CANDLES_TO_FETCH_COUNT * 0.85}:{self.HISTORICAL_CANDLES_TO_FETCH_COUNT}]"
         for candle in historical_ohlcv:
             assert start <= candle[commons_enums.PriceIndexes.IND_PRICE_TIME.value] <= end
 
@@ -263,7 +264,8 @@ def _ensure_book_custom_limit(
     async def get_exchange_manager(self, market_filter=None):
         async with get_exchange_manager(
             self.EXCHANGE_NAME, config=self.get_config(),
-            authenticated=self.REQUIRES_AUTH, market_filter=market_filter
+            authenticated=self.REQUIRES_AUTH, market_filter=market_filter,
+            uses_tentacle=self.USES_TENTACLE
         ) as exchange_manager:
             yield exchange_manager
 

tests_additional/real_exchanges/test_ascendex.py

@@ -60,6 +60,7 @@ async def test_active_symbols(self):
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():
             self.ensure_required_market_status_values(market_status)
+            print(f"market_status: {market_status}")
             # on AscendEx, precision is a decimal instead of a number of digits
             assert 0 < market_status[Ecmsc.PRECISION.value][
                 Ecmsc.PRECISION_AMOUNT.value] <= 1  # to be fixed in AscendEx tentacle

tests_additional/real_exchanges/test_htx.py

@@ -49,7 +49,7 @@ async def test_time_frames(self):
         ))
 
     async def test_active_symbols(self):
-        await self.inner_test_active_symbols(900, 1900)
+        await self.inner_test_active_symbols(850, 1900)
 
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():

tests_additional/real_exchanges/test_hyperliquid.py

@@ -68,7 +68,7 @@ async def test_time_frames(self):
         ))
 
     async def test_active_symbols(self):
-        await self.inner_test_active_symbols(450, 450)
+        await self.inner_test_active_symbols(400, 450)
 
     async def test_get_market_status(self):
         for market_status in await self.get_market_statuses():
@@ -83,7 +83,7 @@ async def test_get_market_status(self):
             assert 0 < market_status[Ecmsc.PRECISION.value][
                 Ecmsc.PRECISION_PRICE.value] <= 1  # to be fixed in Hyperliquid tentacle
             assert all(elem in market_status[Ecmsc.LIMITS.value]
-                       for elem in (Ecmsc.LIMITS_AMOUNT.value,
+                    for elem in (Ecmsc.LIMITS_AMOUNT.value,
                                     Ecmsc.LIMITS_PRICE.value,
                                     Ecmsc.LIMITS_COST.value))
             self.check_market_status_limits(