ccxt 4.2.58__py2.py3-none-any.whl → 4.2.60__py2.py3-none-any.whl

ccxt/pro/bitmart.py

@@ -114,7 +114,8 @@ class bitmart(ccxt.async_support.bitmart):
             }
         return await self.watch(url, messageHash, self.deep_extend(request, params), messageHash)
 
-    async def subscribe_multiple(self, channel: str, type: str, symbols: List[str], params={}):
+    async def subscribe_multiple(self, channel: str, type: str, symbols: Strings = None, params={}):
+        symbols = self.market_symbols(symbols, type, False, True)
         url = self.implode_hostname(self.urls['api']['ws'][type]['public'])
         channelType = 'spot' if (type == 'spot') else 'futures'
         actionType = 'op' if (type == 'spot') else 'action'
@@ -125,6 +126,9 @@ class bitmart(ccxt.async_support.bitmart):
             message = channelType + '/' + channel + ':' + market['id']
             rawSubscriptions.append(message)
             messageHashes.append(channel + ':' + market['symbol'])
+        # exclusion, futures "tickers" need one generic request for all symbols
+        if (type != 'spot') and (channel == 'ticker'):
+            rawSubscriptions = [channelType + '/' + channel]
         request = {
             'args': rawSubscriptions,
         }
@@ -305,12 +309,8 @@ class bitmart(ccxt.async_support.bitmart):
         """
         await self.load_markets()
         symbol = self.symbol(symbol)
-        market = self.market(symbol)
-        type = 'spot'
-        type, params = self.handle_market_type_and_params('watchTicker', market, params)
-        if type == 'swap':
-            raise NotSupported(self.id + ' watchTicker() does not support ' + type + ' markets. Use watchTickers() instead')
-        return await self.subscribe('ticker', symbol, type, params)
+        tickers = await self.watch_tickers([symbol], params)
+        return tickers[symbol]
 
     async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
         """
@@ -322,35 +322,12 @@ class bitmart(ccxt.async_support.bitmart):
         """
         await self.load_markets()
         market = self.get_market_from_symbols(symbols)
-        type = 'spot'
-        type, params = self.handle_market_type_and_params('watchTickers', market, params)
-        url = self.implode_hostname(self.urls['api']['ws'][type]['public'])
-        symbols = self.market_symbols(symbols)
-        messageHash = 'tickers::' + type
-        if symbols is not None:
-            messageHash += '::' + ','.join(symbols)
-        request = None
-        tickers = None
-        isSpot = (type == 'spot')
-        if isSpot:
-            if symbols is None:
-                raise ArgumentsRequired(self.id + ' watchTickers() for ' + type + ' market type requires symbols argument to be provided')
-            marketIds = self.market_ids(symbols)
-            finalArray = []
-            for i in range(0, len(marketIds)):
-                finalArray.append('spot/ticker:' + marketIds[i])
-            request = {
-                'op': 'subscribe',
-                'args': finalArray,
-            }
-            tickers = await self.watch(url, messageHash, self.deep_extend(request, params), messageHash)
-        else:
-            request = {
-                'action': 'subscribe',
-                'args': ['futures/ticker'],
-            }
-            tickers = await self.watch(url, messageHash, self.deep_extend(request, params), messageHash)
+        marketType = None
+        marketType, params = self.handle_market_type_and_params('watchTickers', market, params)
+        ticker = await self.subscribe_multiple('ticker', marketType, symbols, params)
         if self.newUpdates:
+            tickers = {}
+            tickers[ticker['symbol']] = ticker
             return tickers
         return self.filter_by_array(self.tickers, 'symbol', symbols)
 
@@ -799,19 +776,29 @@ class bitmart(ccxt.async_support.bitmart):
         data = self.safe_value(message, 'data')
         if data is None:
             return
-        stored = None
         symbol = None
-        for i in range(0, len(data)):
-            trade = self.parse_ws_trade(data[i])
-            symbol = trade['symbol']
-            tradesLimit = self.safe_integer(self.options, 'tradesLimit', 1000)
-            stored = self.safe_value(self.trades, symbol)
-            if stored is None:
-                stored = ArrayCache(tradesLimit)
-                self.trades[symbol] = stored
-            stored.append(trade)
-        messageHash = 'trade:' + symbol
-        client.resolve(stored, messageHash)
+        length = len(data)
+        isSwap = ('group' in message)
+        if isSwap:
+            # in swap, chronologically decreasing: 1709536849322, 1709536848954,
+            maxLen = max(length - 1, 0)
+            for i in range(maxLen, 0):
+                symbol = self.handle_trade_loop(data[i])
+        else:
+            # in spot, chronologically increasing: 1709536771200, 1709536771226,
+            for i in range(0, length):
+                symbol = self.handle_trade_loop(data[i])
+        client.resolve(self.trades[symbol], 'trade:' + symbol)
+
+    def handle_trade_loop(self, entry):
+        trade = self.parse_ws_trade(entry)
+        symbol = trade['symbol']
+        tradesLimit = self.safe_integer(self.options, 'tradesLimit', 1000)
+        if self.safe_value(self.trades, symbol) is None:
+            self.trades[symbol] = ArrayCache(tradesLimit)
+        stored = self.trades[symbol]
+        stored.append(trade)
+        return symbol
 
     def parse_ws_trade(self, trade, market: Market = None):
         # spot
@@ -890,40 +877,19 @@ class bitmart(ccxt.async_support.bitmart):
         #
         table = self.safe_string(message, 'table')
         isSpot = (table is not None)
-        data = self.safe_value(message, 'data')
-        if data is None:
-            return
+        rawTickers = []
         if isSpot:
-            for i in range(0, len(data)):
-                ticker = self.parse_ticker(data[i])
-                symbol = ticker['symbol']
-                marketId = self.safe_string(ticker['info'], 'symbol')
-                messageHash = table + ':' + marketId
-                self.tickers[symbol] = ticker
-                client.resolve(ticker, messageHash)
-                self.resolve_message_hashes_for_symbol(client, symbol, ticker, 'tickers::')
+            rawTickers = self.safe_list(message, 'data', [])
         else:
-            # on each update for contract markets, single ticker is provided
-            ticker = self.parse_ws_swap_ticker(data)
-            symbol = self.safe_string(ticker, 'symbol')
+            rawTickers = [self.safe_value(message, 'data', {})]
+        if not len(rawTickers):
+            return
+        for i in range(0, len(rawTickers)):
+            ticker = self.parse_ticker(rawTickers[i]) if isSpot else self.parse_ws_swap_ticker(rawTickers[i])
+            symbol = ticker['symbol']
             self.tickers[symbol] = ticker
-            client.resolve(ticker, 'tickers::swap')
-            self.resolve_message_hashes_for_symbol(client, symbol, ticker, 'tickers::')
-
-    def resolve_message_hashes_for_symbol(self, client, symbol, result, prexif):
-        prefixSeparator = '::'
-        symbolsSeparator = ','
-        messageHashes = self.find_message_hashes(client, prexif)
-        for i in range(0, len(messageHashes)):
-            messageHash = messageHashes[i]
-            parts = messageHash.split(prefixSeparator)
-            length = len(parts)
-            symbolsString = parts[length - 1]
-            symbols = symbolsString.split(symbolsSeparator)
-            if self.in_array(symbol, symbols):
-                response = {}
-                response[symbol] = result
-                client.resolve(response, messageHash)
+            messageHash = 'ticker:' + symbol
+            client.resolve(ticker, messageHash)
 
     def parse_ws_swap_ticker(self, ticker, market: Market = None):
         #

ccxt/pro/bitvavo.py

@@ -1020,7 +1020,7 @@ class bitvavo(ccxt.async_support.bitvavo):
         return messageHash
 
     def check_message_hash_does_not_exist(self, messageHash):
-        supressMultipleWsRequestsError = self.safe_value(self.options, 'supressMultipleWsRequestsError', False)
+        supressMultipleWsRequestsError = self.safe_bool(self.options, 'supressMultipleWsRequestsError', False)
         if not supressMultipleWsRequestsError:
             client = self.safe_value(self.clients, self.urls['api']['ws'])
             if client is not None:

ccxt/pro/bybit.py

@@ -885,7 +885,7 @@ class bybit(ccxt.async_support.bybit):
         self.set_positions_cache(client, symbols)
         cache = self.positions
         fetchPositionsSnapshot = self.handle_option('watchPositions', 'fetchPositionsSnapshot', True)
-        awaitPositionsSnapshot = self.safe_value('watchPositions', 'awaitPositionsSnapshot', True)
+        awaitPositionsSnapshot = self.safe_bool('watchPositions', 'awaitPositionsSnapshot', True)
         if fetchPositionsSnapshot and awaitPositionsSnapshot and cache is None:
             snapshot = await client.future('fetchPositionsSnapshot')
             return self.filter_by_symbols_since_limit(snapshot, symbols, since, limit, True)

ccxt/pro/coinex.py

@@ -529,7 +529,7 @@ class coinex(ccxt.async_support.coinex):
             raise NotSupported(self.id + ' watchOHLCV() is only supported for swap markets. Try using fetchOHLCV() instead')
         url = self.urls['api']['ws'][type]
         messageHash = 'ohlcv'
-        watchOHLCVWarning = self.safe_value(self.options, 'watchOHLCVWarning', True)
+        watchOHLCVWarning = self.safe_bool(self.options, 'watchOHLCVWarning', True)
         client = self.safe_value(self.clients, url, {})
         clientSub = self.safe_value(client, 'subscriptions', {})
         existingSubscription = self.safe_value(clientSub, messageHash)

ccxt/pro/cryptocom.py

@@ -515,7 +515,7 @@ class cryptocom(ccxt.async_support.cryptocom):
         client = self.client(url)
         self.set_positions_cache(client, symbols)
         fetchPositionsSnapshot = self.handle_option('watchPositions', 'fetchPositionsSnapshot', True)
-        awaitPositionsSnapshot = self.safe_value('watchPositions', 'awaitPositionsSnapshot', True)
+        awaitPositionsSnapshot = self.safe_bool('watchPositions', 'awaitPositionsSnapshot', True)
         if fetchPositionsSnapshot and awaitPositionsSnapshot and self.positions is None:
             snapshot = await client.future('fetchPositionsSnapshot')
             return self.filter_by_symbols_since_limit(snapshot, symbols, since, limit, True)

ccxt/pro/deribit.py

@@ -10,6 +10,7 @@ from ccxt.base.types import Balances, Int, Order, OrderBook, Str, Ticker, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import ExchangeError
+from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import NotSupported
 
 
@@ -23,10 +24,13 @@ class deribit(ccxt.async_support.deribit):
                 'watchTicker': True,
                 'watchTickers': False,
                 'watchTrades': True,
+                'watchTradesForSymbols': True,
                 'watchMyTrades': True,
                 'watchOrders': True,
                 'watchOrderBook': True,
+                'watchOrderBookForSymbols': True,
                 'watchOHLCV': True,
+                'watchOHLCVForSymbols': True,
             },
             'urls': {
                 'test': {
@@ -37,18 +41,31 @@ class deribit(ccxt.async_support.deribit):
                 },
             },
             'options': {
-                'timeframes': {
-                    '1m': 1,
-                    '3m': 3,
-                    '5m': 5,
-                    '15m': 15,
-                    '30m': 30,
-                    '1h': 60,
-                    '2h': 120,
-                    '4h': 180,
-                    '6h': 360,
-                    '12h': 720,
-                    '1d': '1D',
+                'ws': {
+                    'timeframes': {
+                        '1m': '1',
+                        '3m': '3',
+                        '5m': '5',
+                        '15m': '15',
+                        '30m': '30',
+                        '1h': '60',
+                        '2h': '120',
+                        '4h': '180',
+                        '6h': '360',
+                        '12h': '720',
+                        '1d': '1D',
+                    },
+                    # watchTrades replacement
+                    'watchTradesForSymbols': {
+                        'interval': '100ms',  # 100ms, agg2, raw
+                    },
+                    # watchOrderBook replacement
+                    'watchOrderBookForSymbols': {
+                        'interval': '100ms',  # 100ms, agg2, raw
+                        'useDepthEndpoint': False,  # if True, it will use the {books.group.depth.interval} endpoint instead of the {books.interval} endpoint
+                        'depth': '20',  # 1, 10, 20
+                        'group': 'none',  # none, 1, 2, 5, 10, 25, 100, 250
+                    },
                 },
                 'currencies': ['BTC', 'ETH', 'SOL', 'USDC'],
             },
@@ -222,26 +239,28 @@ class deribit(ccxt.async_support.deribit):
         :param str [params.interval]: specify aggregation and frequency of notifications. Possible values: 100ms, raw
         :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=public-trades>`
         """
-        await self.load_markets()
-        market = self.market(symbol)
-        url = self.urls['api']['ws']
-        interval = self.safe_string(params, 'interval', '100ms')
-        params = self.omit(params, 'interval')
-        channel = 'trades.' + market['id'] + '.' + interval
+        params['callerMethodName'] = 'watchTrades'
+        return await self.watch_trades_for_symbols([symbol], since, limit, params)
+
+    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://docs.deribit.com/#trades-instrument_name-interval
+        :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
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=public-trades>`
+        """
+        interval = None
+        interval, params = self.handle_option_and_params(params, 'watchTradesForSymbols', 'interval', '100ms')
         if interval == 'raw':
             await self.authenticate()
-        message = {
-            'jsonrpc': '2.0',
-            'method': 'public/subscribe',
-            'params': {
-                'channels': [channel],
-            },
-            'id': self.request_id(),
-        }
-        request = self.deep_extend(message, params)
-        trades = await self.watch(url, channel, request, channel, request)
+        trades = await self.watch_multiple_wrapper('trades', interval, symbols, params)
         if self.newUpdates:
-            limit = trades.getLimit(symbol, limit)
+            first = self.safe_dict(trades, 0)
+            tradeSymbol = self.safe_string(first, 'symbol')
+            limit = trades.getLimit(tradeSymbol, limit)
         return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
     def handle_trades(self, client: Client, message):
@@ -266,24 +285,25 @@ class deribit(ccxt.async_support.deribit):
         #         }
         #     }
         #
-        params = self.safe_value(message, 'params', {})
+        params = self.safe_dict(message, 'params', {})
         channel = self.safe_string(params, 'channel', '')
         parts = channel.split('.')
         marketId = self.safe_string(parts, 1)
+        interval = self.safe_string(parts, 2)
         symbol = self.safe_symbol(marketId)
         market = self.safe_market(marketId)
-        trades = self.safe_value(params, 'data', [])
-        stored = self.safe_value(self.trades, symbol)
-        if stored is None:
+        trades = self.safe_list(params, 'data', [])
+        if self.safe_value(self.trades, symbol) is None:
             limit = self.safe_integer(self.options, 'tradesLimit', 1000)
-            stored = ArrayCache(limit)
-            self.trades[symbol] = stored
+            self.trades[symbol] = ArrayCache(limit)
+        stored = self.trades[symbol]
         for i in range(0, len(trades)):
             trade = trades[i]
             parsed = self.parse_trade(trade, market)
             stored.append(parsed)
         self.trades[symbol] = stored
-        client.resolve(self.trades[symbol], channel)
+        messageHash = 'trades|' + symbol + '|' + interval
+        client.resolve(self.trades[symbol], messageHash)
 
     async def watch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
@@ -367,7 +387,7 @@ class deribit(ccxt.async_support.deribit):
 
     async def watch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
-        :see: https://docs.deribit.com/#public-get_book_summary_by_instrument
+        :see: https://docs.deribit.com/#book-instrument_name-group-depth-interval
         watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
         :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
@@ -375,24 +395,34 @@ class deribit(ccxt.async_support.deribit):
         :param str [params.interval]: Frequency of notifications. Events will be aggregated over self interval. Possible values: 100ms, raw
         :returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
         """
-        await self.load_markets()
-        market = self.market(symbol)
-        url = self.urls['api']['ws']
-        interval = self.safe_string(params, 'interval', '100ms')
-        params = self.omit(params, 'interval')
+        params['callerMethodName'] = 'watchOrderBook'
+        return await self.watch_order_book_for_symbols([symbol], limit, params)
+
+    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://docs.deribit.com/#book-instrument_name-group-depth-interval
+        :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
+        :returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
+        """
+        interval = None
+        interval, params = self.handle_option_and_params(params, 'watchOrderBookForSymbols', 'interval', '100ms')
         if interval == 'raw':
             await self.authenticate()
-        channel = 'book.' + market['id'] + '.' + interval
-        subscribe = {
-            'jsonrpc': '2.0',
-            'method': 'public/subscribe',
-            'params': {
-                'channels': [channel],
-            },
-            'id': self.request_id(),
-        }
-        request = self.deep_extend(subscribe, params)
-        orderbook = await self.watch(url, channel, request, channel)
+        descriptor = ''
+        useDepthEndpoint = None  # for more info, see comment in .options
+        useDepthEndpoint, params = self.handle_option_and_params(params, 'watchOrderBookForSymbols', 'useDepthEndpoint', False)
+        if useDepthEndpoint:
+            depth = None
+            depth, params = self.handle_option_and_params(params, 'watchOrderBookForSymbols', 'depth', '20')
+            group = None
+            group, params = self.handle_option_and_params(params, 'watchOrderBookForSymbols', 'group', 'none')
+            descriptor = group + '.' + depth + '.' + interval
+        else:
+            descriptor = interval
+        orderbook = await self.watch_multiple_wrapper('book', descriptor, symbols, params)
         return orderbook.limit()
 
     def handle_order_book(self, client: Client, message):
@@ -444,6 +474,18 @@ class deribit(ccxt.async_support.deribit):
         params = self.safe_value(message, 'params', {})
         data = self.safe_value(params, 'data', {})
         channel = self.safe_string(params, 'channel')
+        parts = channel.split('.')
+        descriptor = ''
+        partsLength = len(parts)
+        isDetailed = partsLength == 5
+        if isDetailed:
+            group = self.safe_string(parts, 2)
+            depth = self.safe_string(parts, 3)
+            interval = self.safe_string(parts, 4)
+            descriptor = group + '.' + depth + '.' + interval
+        else:
+            interval = self.safe_string(parts, 2)
+            descriptor = interval
         marketId = self.safe_string(data, 'instrument_name')
         symbol = self.safe_symbol(marketId)
         timestamp = self.safe_integer(data, 'timestamp')
@@ -459,7 +501,8 @@ class deribit(ccxt.async_support.deribit):
         storedOrderBook['datetime'] = self.iso8601(timestamp)
         storedOrderBook['symbol'] = symbol
         self.orderbooks[symbol] = storedOrderBook
-        client.resolve(storedOrderBook, channel)
+        messageHash = 'book|' + symbol + '|' + descriptor
+        client.resolve(storedOrderBook, messageHash)
 
     def clean_order_book(self, data):
         bids = self.safe_value(data, 'bids', [])
@@ -584,26 +627,28 @@ class deribit(ccxt.async_support.deribit):
         :returns int[][]: A list of candles ordered, open, high, low, close, volume
         """
         await self.load_markets()
-        market = self.market(symbol)
-        url = self.urls['api']['ws']
-        timeframes = self.safe_value(self.options, 'timeframes', {})
-        interval = self.safe_string(timeframes, timeframe)
-        if interval is None:
-            raise NotSupported(self.id + ' self interval is not supported, please provide one of the supported timeframes')
-        channel = 'chart.trades.' + market['id'] + '.' + interval
-        message = {
-            'jsonrpc': '2.0',
-            'method': 'public/subscribe',
-            'params': {
-                'channels': [channel],
-            },
-            'id': self.request_id(),
-        }
-        request = self.deep_extend(message, params)
-        ohlcv = await self.watch(url, channel, request, channel, request)
+        symbol = self.symbol(symbol)
+        ohlcvs = await self.watch_ohlcv_for_symbols([[symbol, timeframe]], since, limit, params)
+        return ohlcvs[symbol][timeframe]
+
+    async def watch_ohlcv_for_symbols(self, symbolsAndTimeframes: List[List[str]], since: Int = None, limit: Int = None, params={}):
+        """
+        watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+        :see: https://docs.deribit.com/#chart-trades-instrument_name-resolution
+        :param str[][] symbolsAndTimeframes: array of arrays containing unified symbols and timeframes to fetch OHLCV data for, example [['BTC/USDT', '1m'], ['LTC/USDT', '5m']]
+        :param int [since]: timestamp in ms of the earliest candle to fetch
+        :param int [limit]: the maximum amount of candles to fetch
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns int[][]: A list of candles ordered, open, high, low, close, volume
+        """
+        symbolsLength = len(symbolsAndTimeframes)
+        if symbolsLength == 0 or not isinstance(symbolsAndTimeframes[0], list):
+            raise ArgumentsRequired(self.id + " watchOHLCVForSymbols() requires a an array of symbols and timeframes, like  [['BTC/USDT', '1m'], ['LTC/USDT', '5m']]")
+        symbol, timeframe, candles = await self.watch_multiple_wrapper('chart.trades', None, symbolsAndTimeframes, params)
         if self.newUpdates:
-            limit = ohlcv.getLimit(market['symbol'], limit)
-        return self.filter_by_since_limit(ohlcv, since, limit, 0, True)
+            limit = candles.getLimit(symbol, limit)
+        filtered = self.filter_by_since_limit(candles, since, limit, 0, True)
+        return self.create_ohlcv_object(symbol, timeframe, filtered)
 
     def handle_ohlcv(self, client: Client, message):
         #
@@ -624,13 +669,43 @@ class deribit(ccxt.async_support.deribit):
         #         }
         #     }
         #
-        params = self.safe_value(message, 'params', {})
+        params = self.safe_dict(message, 'params', {})
         channel = self.safe_string(params, 'channel', '')
         parts = channel.split('.')
         marketId = self.safe_string(parts, 2)
-        symbol = self.safe_symbol(marketId)
-        ohlcv = self.safe_value(params, 'data', {})
-        parsed = [
+        rawTimeframe = self.safe_string(parts, 3)
+        market = self.safe_market(marketId)
+        symbol = market['symbol']
+        wsOptions = self.safe_dict(self.options, 'ws', {})
+        timeframes = self.safe_dict(wsOptions, 'timeframes', {})
+        unifiedTimeframe = self.find_timeframe(rawTimeframe, timeframes)
+        self.ohlcvs[symbol] = self.safe_dict(self.ohlcvs, symbol, {})
+        if self.safe_value(self.ohlcvs[symbol], unifiedTimeframe) is None:
+            limit = self.safe_integer(self.options, 'OHLCVLimit', 1000)
+            self.ohlcvs[symbol][unifiedTimeframe] = ArrayCacheByTimestamp(limit)
+        stored = self.ohlcvs[symbol][unifiedTimeframe]
+        ohlcv = self.safe_dict(params, 'data', {})
+        # data contains a single OHLCV candle
+        parsed = self.parse_ws_ohlcv(ohlcv, market)
+        stored.append(parsed)
+        self.ohlcvs[symbol][unifiedTimeframe] = stored
+        resolveData = [symbol, unifiedTimeframe, stored]
+        messageHash = 'chart.trades|' + symbol + '|' + rawTimeframe
+        client.resolve(resolveData, messageHash)
+
+    def parse_ws_ohlcv(self, ohlcv, market=None) -> list:
+        #
+        #    {
+        #        "c": "28909.0",
+        #        "o": "28915.4",
+        #        "h": "28915.4",
+        #        "l": "28896.1",
+        #        "v": "27.6919",
+        #        "T": 1696687499999,
+        #        "t": 1696687440000
+        #    }
+        #
+        return [
             self.safe_integer(ohlcv, 'tick'),
             self.safe_number(ohlcv, 'open'),
             self.safe_number(ohlcv, 'high'),
@@ -638,13 +713,42 @@ class deribit(ccxt.async_support.deribit):
             self.safe_number(ohlcv, 'close'),
             self.safe_number(ohlcv, 'volume'),
         ]
-        stored = self.safe_value(self.ohlcvs, symbol)
-        if stored is None:
-            limit = self.safe_integer(self.options, 'OHLCVLimit', 1000)
-            stored = ArrayCacheByTimestamp(limit)
-        stored.append(parsed)
-        self.ohlcvs[symbol] = stored
-        client.resolve(stored, channel)
+
+    async def watch_multiple_wrapper(self, channelName: str, channelDescriptor: Str, symbolsArray=None, params={}):
+        await self.load_markets()
+        url = self.urls['api']['ws']
+        rawSubscriptions = []
+        messageHashes = []
+        isOHLCV = (channelName == 'chart.trades')
+        symbols = self.get_list_from_object_values(symbolsArray, 0) if isOHLCV else symbolsArray
+        self.market_symbols(symbols, None, False)
+        for i in range(0, len(symbolsArray)):
+            current = symbolsArray[i]
+            market = None
+            if isOHLCV:
+                market = self.market(current[0])
+                unifiedTf = current[1]
+                rawTf = self.safe_string(self.timeframes, unifiedTf, unifiedTf)
+                channelDescriptor = rawTf
+            else:
+                market = self.market(current)
+            message = channelName + '.' + market['id'] + '.' + channelDescriptor
+            rawSubscriptions.append(message)
+            messageHashes.append(channelName + '|' + market['symbol'] + '|' + channelDescriptor)
+        request = {
+            'jsonrpc': '2.0',
+            'method': 'public/subscribe',
+            'params': {
+                'channels': rawSubscriptions,
+            },
+            'id': self.request_id(),
+        }
+        extendedRequest = self.deep_extend(request, params)
+        maxMessageByteLimit = 32768 - 1  # 'Message Too Big: limit 32768B'
+        jsonedText = self.json(extendedRequest)
+        if len(jsonedText) >= maxMessageByteLimit:
+            raise ExchangeError(self.id + ' requested subscription length over limit, try to reduce symbols amount')
+        return await self.watch_multiple(url, messageHashes, extendedRequest, rawSubscriptions)
 
     def handle_message(self, client: Client, message):
         #

ccxt/pro/gate.py

@@ -769,7 +769,7 @@ class gate(ccxt.async_support.gate):
         client = self.client(url)
         self.set_positions_cache(client, type, symbols)
         fetchPositionsSnapshot = self.handle_option('watchPositions', 'fetchPositionsSnapshot', True)
-        awaitPositionsSnapshot = self.safe_value('watchPositions', 'awaitPositionsSnapshot', True)
+        awaitPositionsSnapshot = self.safe_bool('watchPositions', 'awaitPositionsSnapshot', True)
         cache = self.safe_value(self.positions, type)
         if fetchPositionsSnapshot and awaitPositionsSnapshot and cache is None:
             return await client.future(type + ':fetchPositionsSnapshot')

ccxt/pro/independentreserve.py

@@ -196,7 +196,7 @@ class independentreserve(ccxt.async_support.independentreserve):
             self.handle_deltas(orderbook['bids'], bids)
             orderbook['timestamp'] = timestamp
             orderbook['datetime'] = self.iso8601(timestamp)
-        checksum = self.safe_value(self.options, 'checksum', True)
+        checksum = self.safe_bool(self.options, 'checksum', True)
         if checksum and receivedSnapshot:
             storedAsks = orderbook['asks']
             storedBids = orderbook['bids']

ccxt/pro/kraken.py

@@ -674,7 +674,7 @@ class kraken(ccxt.async_support.kraken):
                 example = self.safe_value(b, 0)
             # don't remove self line or I will poop on your face
             orderbook.limit()
-            checksum = self.safe_value(self.options, 'checksum', True)
+            checksum = self.safe_bool(self.options, 'checksum', True)
             if checksum:
                 priceString = self.safe_string(example, 0)
                 amountString = self.safe_string(example, 1)

ccxt/pro/kucoinfutures.py

@@ -231,7 +231,7 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
         client = self.client(url)
         self.set_position_cache(client, symbol)
         fetchPositionSnapshot = self.handle_option('watchPosition', 'fetchPositionSnapshot', True)
-        awaitPositionSnapshot = self.safe_value('watchPosition', 'awaitPositionSnapshot', True)
+        awaitPositionSnapshot = self.safe_bool('watchPosition', 'awaitPositionSnapshot', True)
         currentPosition = self.get_current_position(symbol)
         if fetchPositionSnapshot and awaitPositionSnapshot and currentPosition is None:
             snapshot = await client.future('fetchPositionSnapshot:' + symbol)