Merge pull request #1628 from Drakkar-Software/dev

Master update

Author: GuillaumeDSM

Meta/Keywords/scripting_library/configuration/profile_data_configuration.py

@@ -559,6 +559,8 @@ def get_oldest_historical_config_symbols_and_time(profile_data: commons_profiles
     first_traded_symbols = _get_all_tentacles_configured_traded_symbols(profile_data, first_historical_config_time)
     last_traded_symbols = _get_all_tentacles_configured_traded_symbols(profile_data, None)
     return list(first_traded_symbols), list(last_traded_symbols), first_historical_config_time
+
+
 def _get_all_tentacles_configured_traded_symbols(
     profile_data: commons_profiles.ProfileData, first_historical_config_time: typing.Optional[float]
 ) -> set:

Trading/Exchange/coinbase/coinbase_exchange.py

@@ -248,7 +248,7 @@ def _get_next_cursor(self, response: dict, func_name: str) -> str:
 
     @ccxt_client_util.converted_ccxt_common_errors
     async def _ensure_auth(self):
-        # Override of ccxt_connector._ensure_auth to use get_open_orders instead
+        # Override of ccxt_connector._ensure_auth to use get_open_orders instead and propagate authentication errors
         try:
             # load markets before calling _ensure_auth() to avoid fetching markets status while they are cached
             with self.error_describer():
@@ -259,9 +259,9 @@ async def _ensure_auth(self):
             # replace self.exchange_manager.exchange.get_balance by get_open_orders
             # to mitigate coinbase balance cache side effect
             await self.exchange_manager.exchange.get_open_orders(symbol="BTC/USDC")
-        except (octobot_trading.errors.AuthenticationError, ccxt.AuthenticationError) as e:
-            await self.client.close()
-            self.unauthenticated_exchange_fallback(e)
+        except (octobot_trading.errors.AuthenticationError, ccxt.AuthenticationError):
+            # this error is critical on coinbase as it prevents loading markets: propagate it
+            raise 
         except Exception as e:
             # Is probably handled in exchange tentacles, important thing here is that authentication worked
             self.logger.debug(f"Error when checking exchange connection: {e}. This should not be an issue.")

Trading/Exchange/hollaex/hollaex_exchange.py

@@ -52,18 +52,47 @@ async def load_symbol_markets(
         market_filter: typing.Union[None, typing.Callable[[dict], bool]] = None
     ):
         await super().load_symbol_markets(reload=reload, market_filter=market_filter)
-        # all_tickers = await self.get_all_currencies_price_ticker()
-        # tradable_symbols = set(
-        #     symbol 
-        #     for symbol, values in all_tickers.items() 
-        #     if values.get(trading_enums.ExchangeConstantsTickersColumns.CLOSE.value, None) != None
-        # )
+        await self.disable_quick_trade_only_pairs()
         # also refresh fee tiers when necessary
         if self.exchange_manager.exchange_name not in _REFRESHED_EXCHANGE_FEE_TIERS_BY_EXCHANGE_NAME:
             # always update fees cache using all markets to avoid market filter side effects from the current client
             all_markets = ccxt_clients_cache.get_exchange_parsed_markets(ccxt_clients_cache.get_client_key(self.client))
             await self._refresh_exchange_fee_tiers(all_markets)
 
+    async def disable_quick_trade_only_pairs(self):
+        # on hollaex exchanges, a market can be "quick trade only" or "spot order book trade" as well.
+        # a quick trade only market can't be traded like a spot market, disable it.
+        exchange_constants = await self.client.publicGetConstants()
+        for quick_trade_only_pairs in self._parse_quick_trades_only_pairs(exchange_constants):
+            self._disable_pair(quick_trade_only_pairs)
+
+    def _disable_pair(self, symbol: str):
+        if symbol in self.client.markets:
+            self.logger.info(f"Disabling [{self.exchange_manager.exchange_name}] quick trade only pair: {symbol}")
+            self.client.markets[symbol][trading_enums.ExchangeConstantsMarketStatusColumns.ACTIVE.value] = False
+
+    def _parse_quick_trades_only_pairs(self, exchange_constants: dict) -> list[str]:
+        if 'quicktrade' not in exchange_constants:
+            self.logger.error(
+                f"Unexpected [{self.exchange_manager.exchange_name}] no 'quicktrade' key found in exchange constants"
+            )
+            return []
+        quick_trade_details = exchange_constants['quicktrade']
+        # format: [{'type': 'network', 'symbol': 'rune-usdt', 'active': True}, ...]
+        quick_trade_only_pairs = []
+        for pair_details in quick_trade_details:
+            if "type" not in pair_details or "symbol" not in pair_details:
+                self.logger.error(f"Ignored invalid quick trade only pair details: {pair_details}")
+                continue
+            # type=pro means this pair is traded in spot order book markets, otherwise it's a quick trade only pair
+            if pair_details['type'] != "pro":
+                market_id = pair_details["symbol"]
+                market = self.client.safe_market(market_id, None, '-')
+                quick_trade_only_pairs.append(
+                    market[trading_enums.ExchangeConstantsMarketStatusColumns.SYMBOL.value]
+                )
+        return quick_trade_only_pairs
+
     async def _refresh_exchange_fee_tiers(self, all_markets: list[dict]):
         self.logger.info(f"Refreshing {self.exchange_manager.exchange_name} fee tiers")
         response = await self.client.publicGetTiers()

Trading/Exchange/hollaex_autofilled/hollaex_autofilled_exchange.py

@@ -135,6 +135,10 @@ async def _retry_fetch_when_rate_limit(cls, session, url):
                 f"Error text: {await response.text()}"
             )
             response.raise_for_status()
+        except aiohttp.ClientResponseError as err:
+            if err.status == 404:
+                raise errors.FailedRequest(f"{url} returned 404: not found: {err.message}") from err
+            raise # forward unexpected errors
         except aiohttp.ClientConnectionError as err:
             raise errors.NetworkError(
                 f"Failed to execute request: {err.__class__.__name__}: {html_util.get_html_summary_if_relevant(err)}"

Trading/Exchange/mexc/mexc_exchange.py

@@ -18,6 +18,7 @@
 import time
 import typing
 import ccxt
+from ccxt.base.types import Entry
 
 import octobot_trading.exchanges as exchanges
 import octobot_trading.exchanges.connectors.ccxt.constants as ccxt_constants
@@ -77,8 +78,18 @@ def get_additional_connector_config(self):
         }
 
     async def get_account_id(self, **kwargs: dict) -> str:
-        # current impossible to get account UID (10/01/25)
-        return constants.DEFAULT_ACCOUNT_ID
+        # https://www.mexc.com/api-docs/spot-v3/spot-account-trade#query-uid
+        private_get_uid = Entry('uid', ['spot', 'private'], 'GET', {'cost': 10})
+        try:
+            resp = await private_get_uid.unbound_method(self.connector.client)
+            return str(resp["uid"])
+        except Exception as err:
+            self.logger.exception(
+                err, 
+                True, 
+                f"Unexpected error when getting {self.get_name()} account ID: {err}. Using default account ID."
+            )
+            return constants.DEFAULT_ACCOUNT_ID
 
     def get_max_orders_count(self, symbol: str, order_type: trading_enums.TraderOrderType) -> int:
         # unknown (05/06/2025)

Trading/Mode/market_making_trading_mode/market_making_trading.py

@@ -74,6 +74,7 @@ class OrdersUpdatePlan:
     order_actions: list[OrderAction] = dataclasses.field(default_factory=list)
     cancelled: bool = False
     cancellable: bool = True
+    force_cancelled: bool = False
     processed: asyncio.Event = dataclasses.field(default_factory=asyncio.Event)
     trigger_source: str = ""
 
@@ -297,7 +298,9 @@ async def _process_plan(self, order_actions_plan: OrdersUpdatePlan, current_pric
         while scheduled_actions:
             action = scheduled_actions.popleft()
             try:
-                if order_actions_plan.cancelled and order_actions_plan.cancellable:
+                if (
+                    (order_actions_plan.cancelled and order_actions_plan.cancellable) or order_actions_plan.force_cancelled
+                ):
                     actions_class = action.__class__.__name__
                     self.logger.debug(
                         f"{self.trading_mode.symbol} {self.exchange_manager.exchange_name} "
@@ -1187,32 +1190,37 @@ def get_market_making_orders(self):
             if isinstance(order, (trading_personal_data.BuyLimitOrder, trading_personal_data.SellLimitOrder))
         ]
 
-    async def _on_reference_price_update(self):
+    async def on_new_reference_price(self, reference_price: decimal.Decimal) -> bool:
         trigger = False
-        if reference_price := await self._get_reference_price():
-            open_orders = self.get_market_making_orders()
-            buy_orders = [
-                order
-                for order in open_orders
-                if order.side == trading_enums.TradeOrderSide.BUY
-            ]
-            if not buy_orders:
+        open_orders = self.get_market_making_orders()
+        buy_orders = [
+            order
+            for order in open_orders
+            if order.side == trading_enums.TradeOrderSide.BUY
+        ]
+        if not buy_orders:
+            trigger = True
+        else:
+            max_buy_price = max(order.origin_price for order in buy_orders)
+            if max_buy_price > reference_price:
                 trigger = True
-            else:
-                max_buy_price = max(order.origin_price for order in buy_orders)
-                if max_buy_price > reference_price:
-                    trigger = True
-            sell_orders = [
-                order
-                for order in open_orders
-                if order.side == trading_enums.TradeOrderSide.SELL
-            ]
-            if not sell_orders:
+        sell_orders = [
+            order
+            for order in open_orders
+            if order.side == trading_enums.TradeOrderSide.SELL
+        ]
+        if not sell_orders:
+            trigger = True
+        else:
+            min_sell_price = min(order.origin_price for order in sell_orders)
+            if min_sell_price < reference_price:
                 trigger = True
-            else:
-                min_sell_price = min(order.origin_price for order in sell_orders)
-                if min_sell_price < reference_price:
-                    trigger = True
+        return trigger
+
+    async def _on_reference_price_update(self):
+        trigger = False
+        if reference_price := await self._get_reference_price():
+            trigger = await self.on_new_reference_price(reference_price)
         if trigger:
             await self._ensure_market_making_orders(f"reference price update: {float(reference_price)}")