ccxt 4.4.1__py2.py3-none-any.whl → 4.4.3__py2.py3-none-any.whl

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.4.1'
+__version__ = '4.4.3'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/binance.py

@@ -14,7 +14,6 @@ from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadRequest
 from ccxt.base.errors import NotSupported
 from ccxt.base.errors import ChecksumError
-from ccxt.base.errors import UnsubscribeError
 from ccxt.base.precise import Precise
 
 
@@ -952,52 +951,9 @@ class binance(ccxt.async_support.binance):
         for j in range(0, len(messageHashes)):
             unsubHash = messageHashes[j]
             subHash = subMessageHashes[j]
-            if unsubHash in client.subscriptions:
-                del client.subscriptions[unsubHash]
-            if subHash in client.subscriptions:
-                del client.subscriptions[subHash]
-            error = UnsubscribeError(self.id + ' ' + subHash)
-            client.reject(error, subHash)
-            client.resolve(True, unsubHash)
+            self.clean_unsubscription(client, subHash, unsubHash)
         self.clean_cache(subscription)
 
-    def clean_cache(self, subscription: dict):
-        topic = self.safe_string(subscription, 'topic')
-        symbols = self.safe_list(subscription, 'symbols', [])
-        symbolsLength = len(symbols)
-        if topic == 'ohlcv':
-            symbolsAndTimeFrames = self.safe_list(subscription, 'symbolsAndTimeframes', [])
-            for i in range(0, len(symbolsAndTimeFrames)):
-                symbolAndTimeFrame = symbolsAndTimeFrames[i]
-                symbol = self.safe_string(symbolAndTimeFrame, 0)
-                timeframe = self.safe_string(symbolAndTimeFrame, 1)
-                if timeframe in self.ohlcvs[symbol]:
-                    del self.ohlcvs[symbol][timeframe]
-        elif symbolsLength > 0:
-            for i in range(0, len(symbols)):
-                symbol = symbols[i]
-                if topic == 'trade':
-                    del self.trades[symbol]
-                elif topic == 'orderbook':
-                    del self.orderbooks[symbol]
-                elif topic == 'ticker':
-                    del self.tickers[symbol]
-        else:
-            if topic == 'myTrades':
-                # don't reset self.myTrades directly here
-                # because in c# we need to use a different object
-                keys = list(self.myTrades.keys())
-                for i in range(0, len(keys)):
-                    del self.myTrades[keys[i]]
-            elif topic == 'orders':
-                orderSymbols = list(self.orders.keys())
-                for i in range(0, len(orderSymbols)):
-                    del self.orders[orderSymbols[i]]
-            elif topic == 'ticker':
-                tickerSymbols = list(self.tickers.keys())
-                for i in range(0, len(tickerSymbols)):
-                    del self.tickers[tickerSymbols[i]]
-
     async def watch_trades_for_symbols(self, symbols: List[str], since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         get the list of most recent trades for a list of symbols
@@ -1106,7 +1062,7 @@ class binance(ccxt.async_support.binance):
             'subMessageHashes': subMessageHashes,
             'messageHashes': messageHashes,
             'symbols': symbols,
-            'topic': 'trade',
+            'topic': 'trades',
         }
         return await self.watch_multiple(url, messageHashes, self.extend(request, query), messageHashes, subscription)
 
@@ -1810,7 +1766,7 @@ class binance(ccxt.async_support.binance):
         result = await self.watch_multi_ticker_helper('watchBidsAsks', 'bookTicker', symbols, params)
         if self.newUpdates:
             return result
-        return self.filter_by_array(self.tickers, 'symbol', symbols)
+        return self.filter_by_array(self.bidsasks, 'symbol', symbols)
 
     async def watch_multi_ticker_helper(self, methodName, channelName: str, symbols: Strings = None, params={}):
         await self.load_markets()

ccxt/pro/bitget.py

@@ -1876,13 +1876,7 @@ class bitget(ccxt.async_support.bitget):
         if symbol in self.ohlcvs:
             if timeframe in self.ohlcvs[symbol]:
                 del self.ohlcvs[symbol][timeframe]
-        if subMessageHash in client.subscriptions:
-            del client.subscriptions[subMessageHash]
-        if messageHash in client.subscriptions:
-            del client.subscriptions[messageHash]
-        error = UnsubscribeError(self.id + ' ohlcv ' + timeframe + ' ' + symbol)
-        client.reject(error, subMessageHash)
-        client.resolve(True, messageHash)
+        self.clean_unsubscription(client, subMessageHash, messageHash)
 
     def handle_un_subscription_status(self, client: Client, message):
         #

ccxt/pro/bitmex.py

@@ -66,6 +66,7 @@ class bitmex(ccxt.async_support.bitmex):
     async def watch_ticker(self, symbol: str, params={}) -> Ticker:
         """
         watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+        :see: https://www.bitmex.com/app/wsAPI#Subscriptions
         :param str symbol: unified symbol of the market to fetch the ticker for
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
@@ -78,6 +79,7 @@ class bitmex(ccxt.async_support.bitmex):
     async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
         """
         watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
+        :see: https://www.bitmex.com/app/wsAPI#Subscriptions
         :param str[] symbols: unified symbol of the market to fetch the ticker for
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
@@ -449,6 +451,7 @@ class bitmex(ccxt.async_support.bitmex):
     async def watch_balance(self, params={}) -> Balances:
         """
         watch balance and get the amount of funds available for trading or funds locked in orders
+        :see: https://www.bitmex.com/app/wsAPI#Subscriptions
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
         """
@@ -651,6 +654,7 @@ class bitmex(ccxt.async_support.bitmex):
     async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         get the list of most recent trades for a particular symbol
+        :see: https://www.bitmex.com/app/wsAPI#Subscriptions
         :param str symbol: unified symbol of the market to fetch trades for
         :param int [since]: timestamp in ms of the earliest trade to fetch
         :param int [limit]: the maximum amount of trades to fetch
@@ -697,8 +701,8 @@ class bitmex(ccxt.async_support.bitmex):
 
     async def watch_positions(self, symbols: Strings = None, since: Int = None, limit: Int = None, params={}) -> List[Position]:
         """
-        :see: https://www.bitmex.com/app/wsAPI
         watch all open positions
+        :see: https://www.bitmex.com/app/wsAPI#Subscriptions
         :param str[]|None symbols: list of unified market symbols
         :param dict params: extra parameters specific to the exchange API endpoint
         :returns dict[]: a list of `position structure <https://docs.ccxt.com/en/latest/manual.html#position-structure>`
@@ -894,6 +898,7 @@ class bitmex(ccxt.async_support.bitmex):
     async def watch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
         watches information on multiple orders made by the user
+        :see: https://www.bitmex.com/app/wsAPI#Subscriptions
         :param str symbol: unified market symbol of the market orders were made in
         :param int [since]: the earliest time in ms to fetch orders for
         :param int [limit]: the maximum number of order structures to retrieve
@@ -1100,6 +1105,7 @@ class bitmex(ccxt.async_support.bitmex):
     async def watch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         watches information on multiple trades made by the user
+        :see: https://www.bitmex.com/app/wsAPI#Subscriptions
         :param str symbol: unified market symbol of the market trades were made in
         :param int [since]: the earliest time in ms to fetch trades for
         :param int [limit]: the maximum number of trade structures to retrieve
@@ -1209,6 +1215,7 @@ class bitmex(ccxt.async_support.bitmex):
     async def watch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
         watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
+        :see: https://www.bitmex.com/app/wsAPI#OrderBookL2
         :param str symbol: unified symbol of the market to fetch the order book for
         :param int [limit]: the maximum amount of order book entries to return
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -1219,6 +1226,7 @@ class bitmex(ccxt.async_support.bitmex):
     async def watch_order_book_for_symbols(self, symbols: List[str], limit: Int = None, params={}) -> OrderBook:
         """
         watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
+        :see: https://www.bitmex.com/app/wsAPI#OrderBookL2
         :param str[] symbols: unified array of symbols
         :param int [limit]: the maximum amount of order book entries to return
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -1255,6 +1263,7 @@ class bitmex(ccxt.async_support.bitmex):
     async def watch_trades_for_symbols(self, symbols: List[str], since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         get the list of most recent trades for a list of symbols
+        :see: https://www.bitmex.com/app/wsAPI#Subscriptions
         :param str[] symbols: unified symbol of the market to fetch trades for
         :param int [since]: timestamp in ms of the earliest trade to fetch
         :param int [limit]: the maximum amount of trades to fetch
@@ -1288,6 +1297,7 @@ class bitmex(ccxt.async_support.bitmex):
     async def watch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
         """
         watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+        :see: https://www.bitmex.com/app/wsAPI#Subscriptions
         :param str symbol: unified symbol of the market to fetch OHLCV data for
         :param str timeframe: the length of time each candle represents
         :param int [since]: timestamp in ms of the earliest candle to fetch

ccxt/pro/bybit.py

@@ -15,7 +15,6 @@ from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadRequest
-from ccxt.base.errors import UnsubscribeError
 
 
 class bybit(ccxt.async_support.bybit):
@@ -953,7 +952,7 @@ class bybit(ccxt.async_support.bybit):
             messageHash = 'unsubscribe:trade:' + symbol
             messageHashes.append(messageHash)
             subMessageHashes.append('trade:' + symbol)
-        return await self.un_watch_topics(url, 'trade', symbols, messageHashes, subMessageHashes, topics, params)
+        return await self.un_watch_topics(url, 'trades', symbols, messageHashes, subMessageHashes, topics, params)
 
     async def un_watch_trades(self, symbol: str, params={}) -> Any:
         """
@@ -2310,44 +2309,6 @@ class bybit(ccxt.async_support.bybit):
                 for j in range(0, len(messageHashes)):
                     unsubHash = messageHashes[j]
                     subHash = subMessageHashes[j]
-                    if unsubHash in client.subscriptions:
-                        del client.subscriptions[unsubHash]
-                    if subHash in client.subscriptions:
-                        del client.subscriptions[subHash]
-                    error = UnsubscribeError(self.id + ' ' + messageHash)
-                    client.reject(error, subHash)
-                    client.resolve(True, unsubHash)
+                    self.clean_unsubscription(client, subHash, unsubHash)
                 self.clean_cache(subscription)
         return message
-
-    def clean_cache(self, subscription: dict):
-        topic = self.safe_string(subscription, 'topic')
-        symbols = self.safe_list(subscription, 'symbols', [])
-        symbolsLength = len(symbols)
-        if topic == 'ohlcv':
-            symbolsAndTimeFrames = self.safe_list(subscription, 'symbolsAndTimeframes', [])
-            for i in range(0, len(symbolsAndTimeFrames)):
-                symbolAndTimeFrame = symbolsAndTimeFrames[i]
-                symbol = self.safe_string(symbolAndTimeFrame, 0)
-                timeframe = self.safe_string(symbolAndTimeFrame, 1)
-                del self.ohlcvs[symbol][timeframe]
-        elif symbolsLength > 0:
-            for i in range(0, len(symbols)):
-                symbol = symbols[i]
-                if topic == 'trade':
-                    del self.trades[symbol]
-                elif topic == 'orderbook':
-                    del self.orderbooks[symbol]
-                elif topic == 'ticker':
-                    del self.tickers[symbol]
-        else:
-            if topic == 'myTrades':
-                # don't reset self.myTrades directly here
-                # because in c# we need to use a different object
-                keys = list(self.myTrades.keys())
-                for i in range(0, len(keys)):
-                    del self.myTrades[keys[i]]
-            elif topic == 'orders':
-                orderSymbols = list(self.orders.keys())
-                for i in range(0, len(orderSymbols)):
-                    del self.orders[orderSymbols[i]]

ccxt/pro/cryptocom.py

@@ -6,7 +6,7 @@
 import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheBySymbolBySide, ArrayCacheByTimestamp
 import hashlib
-from ccxt.base.types import Balances, Int, Num, Order, OrderBook, OrderSide, OrderType, Position, Str, Strings, Ticker, Trade
+from ccxt.base.types import Balances, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from typing import Any
@@ -14,7 +14,6 @@ from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import NetworkError
 from ccxt.base.errors import ChecksumError
-from ccxt.base.errors import UnsubscribeError
 
 
 class cryptocom(ccxt.async_support.cryptocom):
@@ -25,7 +24,8 @@ class cryptocom(ccxt.async_support.cryptocom):
                 'ws': True,
                 'watchBalance': True,
                 'watchTicker': True,
-                'watchTickers': False,
+                'watchTickers': True,
+                'watchBidsAsks': True,
                 'watchMyTrades': True,
                 'watchTrades': True,
                 'watchTradesForSymbols': True,
@@ -349,7 +349,7 @@ class cryptocom(ccxt.async_support.cryptocom):
             currentTopic = 'trade' + '.' + market['id']
             messageHashes.append('unsubscribe:trades:' + market['symbol'])
             topics.append(currentTopic)
-        return await self.un_watch_public_multiple('trade', symbols, messageHashes, topics, topics, params)
+        return await self.un_watch_public_multiple('trades', symbols, messageHashes, topics, topics, params)
 
     def handle_trades(self, client: Client, message):
         #
@@ -444,40 +444,198 @@ class cryptocom(ccxt.async_support.cryptocom):
         messageHash = 'unsubscribe:ticker:' + market['symbol']
         return await self.un_watch_public_multiple('ticker', [market['symbol']], [messageHash], [subMessageHash], [subMessageHash], params)
 
+    async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+        watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
+        :see: https://exchange-docs.crypto.com/exchange/v1/rest-ws/index.html#ticker-instrument_name
+        :param str[] symbols: unified symbol of the market to fetch the ticker for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, False)
+        messageHashes = []
+        marketIds = self.market_ids(symbols)
+        for i in range(0, len(marketIds)):
+            marketId = marketIds[i]
+            messageHashes.append('ticker.' + marketId)
+        url = self.urls['api']['ws']['public']
+        id = self.nonce()
+        request: dict = {
+            'method': 'subscribe',
+            'params': {
+                'channels': messageHashes,
+            },
+            'nonce': id,
+        }
+        ticker = await self.watch_multiple(url, messageHashes, self.extend(request, params), messageHashes)
+        if self.newUpdates:
+            result: dict = {}
+            result[ticker['symbol']] = ticker
+            return result
+        return self.filter_by_array(self.tickers, 'symbol', symbols)
+
+    async def un_watch_tickers(self, symbols: Strings = None, params={}) -> Any:
+        """
+        unWatches a price ticker
+        :see: https://exchange-docs.crypto.com/exchange/v1/rest-ws/index.html#ticker-instrument_name
+        :param str[] symbols: unified symbol of the market to fetch the ticker for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, False)
+        messageHashes = []
+        subMessageHashes = []
+        marketIds = self.market_ids(symbols)
+        for i in range(0, len(marketIds)):
+            marketId = marketIds[i]
+            symbol = symbols[i]
+            subMessageHashes.append('ticker.' + marketId)
+            messageHashes.append('unsubscribe:ticker:' + symbol)
+        return await self.un_watch_public_multiple('ticker', symbols, messageHashes, subMessageHashes, subMessageHashes, params)
+
     def handle_ticker(self, client: Client, message):
         #
-        # {
-        #     "info":{
-        #        "instrument_name":"BTC_USDT",
-        #        "subscription":"ticker.BTC_USDT",
-        #        "channel":"ticker",
-        #        "data":[
-        #           {
-        #              "i":"BTC_USDT",
-        #              "b":43063.19,
-        #              "k":43063.2,
-        #              "a":43063.19,
-        #              "t":1648121165658,
-        #              "v":43573.912409,
-        #              "h":43498.51,
-        #              "l":41876.58,
-        #              "c":1087.43
-        #           }
-        #        ]
+        #     {
+        #       "instrument_name": "ETHUSD-PERP",
+        #       "subscription": "ticker.ETHUSD-PERP",
+        #       "channel": "ticker",
+        #       "data": [
+        #         {
+        #           "h": "2400.20",
+        #           "l": "2277.10",
+        #           "a": "2335.25",
+        #           "c": "-0.0022",
+        #           "b": "2335.10",
+        #           "bs": "5.4000",
+        #           "k": "2335.16",
+        #           "ks": "1.9970",
+        #           "i": "ETHUSD-PERP",
+        #           "v": "1305697.6462",
+        #           "vv": "3058704939.17",
+        #           "oi": "161646.3614",
+        #           "t": 1726069647560
+        #         }
+        #       ]
         #     }
-        #  }
         #
+        self.handle_bid_ask(client, message)
         messageHash = self.safe_string(message, 'subscription')
         marketId = self.safe_string(message, 'instrument_name')
         market = self.safe_market(marketId)
         data = self.safe_value(message, 'data', [])
         for i in range(0, len(data)):
             ticker = data[i]
-            parsed = self.parse_ticker(ticker, market)
+            parsed = self.parse_ws_ticker(ticker, market)
             symbol = parsed['symbol']
             self.tickers[symbol] = parsed
             client.resolve(parsed, messageHash)
 
+    def parse_ws_ticker(self, ticker: dict, market: Market = None) -> Ticker:
+        #
+        #     {
+        #       "h": "2400.20",
+        #       "l": "2277.10",
+        #       "a": "2335.25",
+        #       "c": "-0.0022",
+        #       "b": "2335.10",
+        #       "bs": "5.4000",
+        #       "k": "2335.16",
+        #       "ks": "1.9970",
+        #       "i": "ETHUSD-PERP",
+        #       "v": "1305697.6462",
+        #       "vv": "3058704939.17",
+        #       "oi": "161646.3614",
+        #       "t": 1726069647560
+        #     }
+        #
+        timestamp = self.safe_integer(ticker, 't')
+        marketId = self.safe_string(ticker, 'i')
+        market = self.safe_market(marketId, market, '_')
+        quote = self.safe_string(market, 'quote')
+        last = self.safe_string(ticker, 'a')
+        return self.safe_ticker({
+            'symbol': market['symbol'],
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'high': self.safe_number(ticker, 'h'),
+            'low': self.safe_number(ticker, 'l'),
+            'bid': self.safe_number(ticker, 'b'),
+            'bidVolume': self.safe_number(ticker, 'bs'),
+            'ask': self.safe_number(ticker, 'k'),
+            'askVolume': self.safe_number(ticker, 'ks'),
+            'vwap': None,
+            'open': None,
+            'close': last,
+            'last': last,
+            'previousClose': None,
+            'change': None,
+            'percentage': self.safe_string(ticker, 'c'),
+            'average': None,
+            'baseVolume': self.safe_string(ticker, 'v'),
+            'quoteVolume': self.safe_string(ticker, 'vv') if (quote == 'USD') else None,
+            'info': ticker,
+        }, market)
+
+    async def watch_bids_asks(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+        :see: https://exchange-docs.crypto.com/exchange/v1/rest-ws/index.html#ticker-instrument_name
+        watches best bid & ask for symbols
+        :param str[] symbols: unified symbol of the market to fetch the ticker for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, False)
+        messageHashes = []
+        topics = []
+        marketIds = self.market_ids(symbols)
+        for i in range(0, len(marketIds)):
+            marketId = marketIds[i]
+            messageHashes.append('bidask.' + symbols[i])
+            topics.append('ticker.' + marketId)
+        url = self.urls['api']['ws']['public']
+        id = self.nonce()
+        request: dict = {
+            'method': 'subscribe',
+            'params': {
+                'channels': topics,
+            },
+            'nonce': id,
+        }
+        newTickers = await self.watch_multiple(url, messageHashes, self.extend(request, params), messageHashes)
+        if self.newUpdates:
+            tickers: dict = {}
+            tickers[newTickers['symbol']] = newTickers
+            return tickers
+        return self.filter_by_array(self.bidsasks, 'symbol', symbols)
+
+    def handle_bid_ask(self, client: Client, message):
+        data = self.safe_list(message, 'data', [])
+        ticker = self.safe_dict(data, 0, {})
+        parsedTicker = self.parse_ws_bid_ask(ticker)
+        symbol = parsedTicker['symbol']
+        self.bidsasks[symbol] = parsedTicker
+        messageHash = 'bidask.' + symbol
+        client.resolve(parsedTicker, messageHash)
+
+    def parse_ws_bid_ask(self, ticker, market=None):
+        marketId = self.safe_string(ticker, 'i')
+        market = self.safe_market(marketId, market)
+        symbol = self.safe_string(market, 'symbol')
+        timestamp = self.safe_integer(ticker, 't')
+        return self.safe_ticker({
+            'symbol': symbol,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'ask': self.safe_string(ticker, 'k'),
+            'askVolume': self.safe_string(ticker, 'ks'),
+            'bid': self.safe_string(ticker, 'b'),
+            'bidVolume': self.safe_string(ticker, 'bs'),
+            'info': ticker,
+        }, market)
+
     async def watch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:
         """
         watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
@@ -1118,33 +1276,5 @@ class cryptocom(ccxt.async_support.cryptocom):
                 for j in range(0, len(messageHashes)):
                     unsubHash = messageHashes[j]
                     subHash = subMessageHashes[j]
-                    if unsubHash in client.subscriptions:
-                        del client.subscriptions[unsubHash]
-                    if subHash in client.subscriptions:
-                        del client.subscriptions[subHash]
-                    error = UnsubscribeError(self.id + ' ' + subHash)
-                    client.reject(error, subHash)
-                    client.resolve(True, unsubHash)
+                    self.clean_unsubscription(client, subHash, unsubHash)
                 self.clean_cache(subscription)
-
-    def clean_cache(self, subscription: dict):
-        topic = self.safe_string(subscription, 'topic')
-        symbols = self.safe_list(subscription, 'symbols', [])
-        symbolsLength = len(symbols)
-        if topic == 'ohlcv':
-            symbolsAndTimeFrames = self.safe_list(subscription, 'symbolsAndTimeframes', [])
-            for i in range(0, len(symbolsAndTimeFrames)):
-                symbolAndTimeFrame = symbolsAndTimeFrames[i]
-                symbol = self.safe_string(symbolAndTimeFrame, 0)
-                timeframe = self.safe_string(symbolAndTimeFrame, 1)
-                if timeframe in self.ohlcvs[symbol]:
-                    del self.ohlcvs[symbol][timeframe]
-        elif symbolsLength > 0:
-            for i in range(0, len(symbols)):
-                symbol = symbols[i]
-                if topic == 'trade':
-                    del self.trades[symbol]
-                elif topic == 'orderbook':
-                    del self.orderbooks[symbol]
-                elif topic == 'ticker':
-                    del self.tickers[symbol]

ccxt/pro/gate.py

@@ -16,7 +16,6 @@ from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadRequest
 from ccxt.base.errors import NotSupported
 from ccxt.base.errors import ChecksumError
-from ccxt.base.errors import UnsubscribeError
 from ccxt.base.precise import Precise
 
 
@@ -1539,13 +1538,7 @@ class gate(ccxt.async_support.gate):
                 for j in range(0, len(messageHashes)):
                     unsubHash = messageHashes[j]
                     subHash = subMessageHashes[j]
-                    if unsubHash in client.subscriptions:
-                        del client.subscriptions[unsubHash]
-                    if subHash in client.subscriptions:
-                        del client.subscriptions[subHash]
-                    error = UnsubscribeError(self.id + ' ' + messageHash)
-                    client.reject(error, subHash)
-                    client.resolve(True, unsubHash)
+                    self.clean_unsubscription(client, subHash, unsubHash)
                 self.clean_cache(subscription)
 
     def clean_cache(self, subscription: dict):

ccxt/pro/hyperliquid.py

@@ -10,7 +10,6 @@ from ccxt.async_support.base.ws.client import Client
 from typing import List
 from typing import Any
 from ccxt.base.errors import ExchangeError
-from ccxt.base.errors import UnsubscribeError
 
 
 class hyperliquid(ccxt.async_support.hyperliquid):
@@ -805,13 +804,7 @@ class hyperliquid(ccxt.async_support.hyperliquid):
         symbol = self.safe_symbol(marketId)
         subMessageHash = 'orderbook:' + symbol
         messageHash = 'unsubscribe:' + subMessageHash
-        if messageHash in client.subscriptions:
-            del client.subscriptions[messageHash]
-        if subMessageHash in client.subscriptions:
-            del client.subscriptions[subMessageHash]
-        error = UnsubscribeError(self.id + ' ' + subMessageHash)
-        client.reject(error, subMessageHash)
-        client.resolve(True, messageHash)
+        self.clean_unsubscription(client, subMessageHash, messageHash)
         if symbol in self.orderbooks:
             del self.orderbooks[symbol]
 
@@ -822,13 +815,7 @@ class hyperliquid(ccxt.async_support.hyperliquid):
         symbol = self.safe_symbol(marketId)
         subMessageHash = 'trade:' + symbol
         messageHash = 'unsubscribe:' + subMessageHash
-        if messageHash in client.subscriptions:
-            del client.subscriptions[messageHash]
-        if subMessageHash in client.subscriptions:
-            del client.subscriptions[subMessageHash]
-        error = UnsubscribeError(self.id + ' ' + subMessageHash)
-        client.reject(error, subMessageHash)
-        client.resolve(True, messageHash)
+        self.clean_unsubscription(client, subMessageHash, messageHash)
         if symbol in self.trades:
             del self.trades[symbol]
 
@@ -836,13 +823,7 @@ class hyperliquid(ccxt.async_support.hyperliquid):
         #
         subMessageHash = 'tickers'
         messageHash = 'unsubscribe:' + subMessageHash
-        if messageHash in client.subscriptions:
-            del client.subscriptions[messageHash]
-        if subMessageHash in client.subscriptions:
-            del client.subscriptions[subMessageHash]
-        error = UnsubscribeError(self.id + ' ' + subMessageHash)
-        client.reject(error, subMessageHash)
-        client.resolve(True, messageHash)
+        self.clean_unsubscription(client, subMessageHash, messageHash)
         symbols = list(self.tickers.keys())
         for i in range(0, len(symbols)):
             del self.tickers[symbols[i]]
@@ -855,13 +836,7 @@ class hyperliquid(ccxt.async_support.hyperliquid):
         timeframe = self.find_timeframe(interval)
         subMessageHash = 'candles:' + timeframe + ':' + symbol
         messageHash = 'unsubscribe:' + subMessageHash
-        if messageHash in client.subscriptions:
-            del client.subscriptions[messageHash]
-        if subMessageHash in client.subscriptions:
-            del client.subscriptions[subMessageHash]
-        error = UnsubscribeError(self.id + ' ' + subMessageHash)
-        client.reject(error, subMessageHash)
-        client.resolve(True, messageHash)
+        self.clean_unsubscription(client, subMessageHash, messageHash)
         if symbol in self.ohlcvs:
             if timeframe in self.ohlcvs[symbol]:
                 del self.ohlcvs[symbol][timeframe]