ccxt 4.2.84__py2.py3-none-any.whl → 4.2.85__py2.py3-none-any.whl

ccxt/phemex.py

@@ -1266,7 +1266,7 @@ class phemex(Exchange, ImplicitAPI):
         #     }
         #
         data = self.safe_value(response, 'data', {})
-        rows = self.safe_value(data, 'rows', [])
+        rows = self.safe_list(data, 'rows', [])
         return self.parse_ohlcvs(rows, market, timeframe, since, userLimit)
 
     def parse_ticker(self, ticker, market: Market = None) -> Ticker:
@@ -1422,7 +1422,7 @@ class phemex(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        result = self.safe_value(response, 'result', {})
+        result = self.safe_dict(response, 'result', {})
         return self.parse_ticker(result, market)
 
     def fetch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
@@ -1452,7 +1452,7 @@ class phemex(Exchange, ImplicitAPI):
             response = self.v1GetMdTicker24hrAll(query)
         else:
             response = self.v2GetMdV2Ticker24hrAll(query)
-        result = self.safe_value(response, 'result', [])
+        result = self.safe_list(response, 'result', [])
         return self.parse_tickers(result, symbols)
 
     def fetch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
@@ -2587,7 +2587,7 @@ class phemex(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        data = self.safe_value(response, 'data', {})
+        data = self.safe_dict(response, 'data', {})
         return self.parse_order(data, market)
 
     def edit_order(self, id: str, symbol: str, type: OrderType = None, side: OrderSide = None, amount: Num = None, price: Num = None, params={}):
@@ -2648,7 +2648,7 @@ class phemex(Exchange, ImplicitAPI):
             response = self.privatePutOrdersReplace(self.extend(request, params))
         else:
             response = self.privatePutSpotOrders(self.extend(request, params))
-        data = self.safe_value(response, 'data', {})
+        data = self.safe_dict(response, 'data', {})
         return self.parse_order(data, market)
 
     def cancel_order(self, id: str, symbol: Str = None, params={}):
@@ -2684,7 +2684,7 @@ class phemex(Exchange, ImplicitAPI):
             response = self.privateDeleteOrdersCancel(self.extend(request, params))
         else:
             response = self.privateDeleteSpotOrders(self.extend(request, params))
-        data = self.safe_value(response, 'data', {})
+        data = self.safe_dict(response, 'data', {})
         return self.parse_order(data, market)
 
     def cancel_all_orders(self, symbol: Str = None, params={}):
@@ -2782,7 +2782,7 @@ class phemex(Exchange, ImplicitAPI):
         else:
             response = self.privateGetSpotOrders(self.extend(request, params))
         data = self.safe_value(response, 'data', {})
-        rows = self.safe_value(data, 'rows', data)
+        rows = self.safe_list(data, 'rows', data)
         return self.parse_orders(rows, market, since, limit)
 
     def fetch_open_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
@@ -2821,7 +2821,7 @@ class phemex(Exchange, ImplicitAPI):
         if isinstance(data, list):
             return self.parse_orders(data, market, since, limit)
         else:
-            rows = self.safe_value(data, 'rows', [])
+            rows = self.safe_list(data, 'rows', [])
             return self.parse_orders(rows, market, since, limit)
 
     def fetch_closed_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
@@ -2898,7 +2898,7 @@ class phemex(Exchange, ImplicitAPI):
         if isinstance(data, list):
             return self.parse_orders(data, market, since, limit)
         else:
-            rows = self.safe_value(data, 'rows', [])
+            rows = self.safe_list(data, 'rows', [])
             return self.parse_orders(rows, market, since, limit)
 
     def fetch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
@@ -3942,7 +3942,7 @@ class phemex(Exchange, ImplicitAPI):
         #
         #
         data = self.safe_value(response, 'data', {})
-        riskLimits = self.safe_value(data, 'riskLimits')
+        riskLimits = self.safe_list(data, 'riskLimits')
         return self.parse_leverage_tiers(riskLimits, symbols, 'symbol')
 
     def parse_market_leverage_tiers(self, info, market: Market = None):
@@ -4173,7 +4173,7 @@ class phemex(Exchange, ImplicitAPI):
         #     }
         #
         data = self.safe_value(response, 'data', {})
-        transfers = self.safe_value(data, 'rows', [])
+        transfers = self.safe_list(data, 'rows', [])
         return self.parse_transfers(transfers, currency, since, limit)
 
     def parse_transfer(self, transfer, currency: Currency = None):
@@ -4375,7 +4375,7 @@ class phemex(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        data = self.safe_value(response, 'data', {})
+        data = self.safe_dict(response, 'data', {})
         return self.parse_transaction(data, currency)
 
     def handle_errors(self, httpCode, reason, url, method, headers, body, response, requestHeaders, requestBody):

ccxt/poloniexfutures.py

@@ -665,7 +665,7 @@ class poloniexfutures(Exchange, ImplicitAPI):
         #        },
         #    }
         #
-        trades = self.safe_value(response, 'data', [])
+        trades = self.safe_list(response, 'data', [])
         return self.parse_trades(trades, market, since, limit)
 
     def fetch_time(self, params={}):
@@ -729,7 +729,7 @@ class poloniexfutures(Exchange, ImplicitAPI):
         #        ]
         #    }
         #
-        data = self.safe_value(response, 'data', [])
+        data = self.safe_list(response, 'data', [])
         return self.parse_ohlcvs(data, market, timeframe, since, limit)
 
     def parse_balance(self, response) -> Balances:
@@ -970,7 +970,7 @@ class poloniexfutures(Exchange, ImplicitAPI):
         #        ]
         #    }
         #
-        data = self.safe_value(response, 'data')
+        data = self.safe_list(response, 'data')
         return self.parse_positions(data, symbols)
 
     def parse_position(self, position, market: Market = None):
@@ -1389,7 +1389,7 @@ class poloniexfutures(Exchange, ImplicitAPI):
         #    }
         #
         market = self.market(symbol) if (symbol is not None) else None
-        responseData = self.safe_value(response, 'data')
+        responseData = self.safe_dict(response, 'data')
         return self.parse_order(responseData, market)
 
     def parse_order(self, order, market: Market = None) -> Order:
@@ -1616,7 +1616,7 @@ class poloniexfutures(Exchange, ImplicitAPI):
         #    }
         #
         data = self.safe_value(response, 'data', {})
-        trades = self.safe_value(data, 'items', {})
+        trades = self.safe_list(data, 'items', [])
         return self.parse_trades(trades, market, since, limit)
 
     def set_margin_mode(self, marginMode: str, symbol: Str = None, params={}):

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.2.84'
+__version__ = '4.2.85'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/binance.py

@@ -12,6 +12,7 @@ from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadRequest
+from ccxt.base.errors import NotSupported
 from ccxt.base.precise import Precise
 
 
@@ -22,6 +23,7 @@ class binance(ccxt.async_support.binance):
             'has': {
                 'ws': True,
                 'watchBalance': True,
+                'watchBidsAsks': True,
                 'watchMyTrades': True,
                 'watchOHLCV': True,
                 'watchOHLCVForSymbols': False,
@@ -103,10 +105,10 @@ class binance(ccxt.async_support.binance):
                     'name': 'trade',  # 'trade' or 'aggTrade'
                 },
                 'watchTicker': {
-                    'name': 'ticker',  # ticker = 1000ms L1+OHLCV, bookTicker = real-time L1
+                    'name': 'ticker',  # ticker or miniTicker or ticker_<window_size>
                 },
                 'watchTickers': {
-                    'name': 'ticker',  # ticker or miniTicker or bookTicker
+                    'name': 'ticker',  # ticker or miniTicker or ticker_<window_size>
                 },
                 'watchOHLCV': {
                     'name': 'kline',  # or indexPriceKline or markPriceKline(coin-m futures)
@@ -127,6 +129,15 @@ class binance(ccxt.async_support.binance):
                 'ws': {
                     'cost': 5,
                 },
+                'tickerChannelsMap': {
+                    '24hrTicker': 'ticker',
+                    '24hrMiniTicker': 'miniTicker',
+                    # rolling window tickers
+                    '1hTicker': 'ticker_1h',
+                    '4hTicker': 'ticker_4h',
+                    '1dTicker': 'ticker_1d',
+                    'bookTicker': 'bookTicker',
+                },
             },
         })
 
@@ -867,33 +878,13 @@ class binance(ccxt.async_support.binance):
         watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
         :param str symbol: unified symbol of the market to fetch the ticker for
         :param dict [params]: extra parameters specific to the exchange API endpoint
-        :param str [params.name]: stream to use can be ticker or bookTicker
+        :param str [params.name]: stream to use can be ticker or miniTicker
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
         await self.load_markets()
-        market = self.market(symbol)
-        marketId = market['lowercaseId']
-        type = market['type']
-        if market['contract']:
-            type = 'future' if market['linear'] else 'delivery'
-        options = self.safe_value(self.options, 'watchTicker', {})
-        name = self.safe_string(options, 'name', 'ticker')
-        name = self.safe_string(params, 'name', name)
-        params = self.omit(params, 'name')
-        messageHash = marketId + '@' + name
-        url = self.urls['api']['ws'][type] + '/' + self.stream(type, messageHash)
-        requestId = self.request_id(url)
-        request = {
-            'method': 'SUBSCRIBE',
-            'params': [
-                messageHash,
-            ],
-            'id': requestId,
-        }
-        subscribe = {
-            'id': requestId,
-        }
-        return await self.watch(url, messageHash, self.extend(request, params), messageHash, subscribe)
+        symbol = self.symbol(symbol)
+        tickers = await self.watch_tickers([symbol], self.extend(params, {'callerMethodName': 'watchTicker'}))
+        return tickers[symbol]
 
     async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
         """
@@ -902,52 +893,89 @@ class binance(ccxt.async_support.binance):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
+        channelName = None
+        channelName, params = self.handle_option_and_params(params, 'watchTickers', 'name', 'ticker')
+        if channelName == 'bookTicker':
+            raise BadRequest(self.id + ' deprecation notice - to subscribe for bids-asks, use watch_bids_asks() method instead')
+        newTickers = await self.watch_multi_ticker_helper('watchTickers', channelName, symbols, params)
+        if self.newUpdates:
+            return newTickers
+        return self.filter_by_array(self.tickers, 'symbol', symbols)
+
+    async def watch_bids_asks(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+        :see: https://binance-docs.github.io/apidocs/spot/en/#individual-symbol-book-ticker-streams
+        :see: https://binance-docs.github.io/apidocs/futures/en/#all-book-tickers-stream
+        :see: https://binance-docs.github.io/apidocs/delivery/en/#all-book-tickers-stream
+        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>`
+        """
+        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)
+
+    async def watch_multi_ticker_helper(self, methodName, channelName: str, symbols: Strings = None, params={}):
         await self.load_markets()
-        symbols = self.market_symbols(symbols, None, True, True, True)
-        marketIds = self.market_ids(symbols)
-        market = None
-        type = None
-        if symbols is not None:
-            market = self.market(symbols[0])
-        type, params = self.handle_market_type_and_params('watchTickers', market, params)
+        symbols = self.market_symbols(symbols, None, True, False, True)
+        firstMarket = None
+        marketType = None
+        symbolsDefined = (symbols is not None)
+        if symbolsDefined:
+            firstMarket = self.market(symbols[0])
+        marketType, params = self.handle_market_type_and_params(methodName, firstMarket, params)
         subType = None
-        subType, params = self.handle_sub_type_and_params('watchTickers', market, params)
-        if self.isLinear(type, subType):
-            type = 'future'
-        elif self.isInverse(type, subType):
-            type = 'delivery'
-        options = self.safe_value(self.options, 'watchTickers', {})
-        name = self.safe_string(options, 'name', 'ticker')
-        name = self.safe_string(params, 'name', name)
-        params = self.omit(params, 'name')
-        wsParams = []
-        messageHash = 'tickers'
-        if symbols is not None:
-            messageHash = 'tickers::' + ','.join(symbols)
-        if name == 'bookTicker':
-            if marketIds is None:
-                raise ArgumentsRequired(self.id + ' watchTickers() requires symbols for bookTicker')
-            # simulate watchTickers with subscribe multiple individual bookTicker topic
-            for i in range(0, len(marketIds)):
-                wsParams.append(marketIds[i].lower() + '@bookTicker')
+        subType, params = self.handle_sub_type_and_params(methodName, firstMarket, params)
+        rawMarketType = None
+        if self.isLinear(marketType, subType):
+            rawMarketType = 'future'
+        elif self.isInverse(marketType, subType):
+            rawMarketType = 'delivery'
+        elif marketType == 'spot':
+            rawMarketType = marketType
         else:
-            wsParams = [
-                '!' + name + '@arr',
-            ]
-        url = self.urls['api']['ws'][type] + '/' + self.stream(type, messageHash)
+            raise NotSupported(self.id + ' ' + methodName + '() does not support options markets')
+        isBidAsk = (channelName == 'bookTicker')
+        subscriptionArgs = []
+        messageHashes = []
+        if symbolsDefined:
+            for i in range(0, len(symbols)):
+                symbol = symbols[i]
+                market = self.market(symbol)
+                subscriptionArgs.append(market['lowercaseId'] + '@' + channelName)
+                messageHashes.append(self.get_message_hash(channelName, market['symbol'], isBidAsk))
+        else:
+            if isBidAsk:
+                if marketType == 'spot':
+                    raise ArgumentsRequired(self.id + ' ' + methodName + '() requires symbols for self channel for spot markets')
+                subscriptionArgs.append('!' + channelName)
+            else:
+                subscriptionArgs.append('!' + channelName + '@arr')
+            messageHashes.append(self.get_message_hash(channelName, None, isBidAsk))
+        streamHash = channelName
+        if symbolsDefined:
+            streamHash = channelName + '::' + ','.join(symbols)
+        url = self.urls['api']['ws'][rawMarketType] + '/' + self.stream(rawMarketType, streamHash)
         requestId = self.request_id(url)
         request = {
             'method': 'SUBSCRIBE',
-            'params': wsParams,
+            'params': subscriptionArgs,
             'id': requestId,
         }
         subscribe = {
             'id': requestId,
         }
-        newTickers = await self.watch(url, messageHash, self.extend(request, params), messageHash, subscribe)
-        if self.newUpdates:
-            return newTickers
-        return self.filter_by_array(self.tickers, 'symbol', symbols)
+        result = await self.watch_multiple(url, messageHashes, self.deep_extend(request, params), subscriptionArgs, subscribe)
+        # for efficiency, we have two type of returned structure here - if symbols array was provided, then individual
+        # ticker dict comes in, otherwise all-tickers dict comes in
+        if not symbolsDefined:
+            return result
+        else:
+            newDict = {}
+            newDict[result['symbol']] = result
+            return newDict
 
     def parse_ws_ticker(self, message, marketType):
         #
@@ -1028,11 +1056,24 @@ class binance(ccxt.async_support.binance):
             'info': message,
         }, market)
 
-    def handle_ticker(self, client: Client, message):
+    def handle_bids_asks(self, client: Client, message):
+        #
+        # arrives one symbol dict or array of symbol dicts
+        #
+        #     {
+        #         "u": 7488717758,
+        #         "s": "BTCUSDT",
+        #         "b": "28621.74000000",
+        #         "B": "1.43278800",
+        #         "a": "28621.75000000",
+        #         "A": "2.52500800"
+        #     }
+        #
+        self.handle_tickers_and_bids_asks(client, message, 'bidasks')
+
+    def handle_tickers(self, client: Client, message):
         #
-        # 24hr rolling window ticker statistics for a single symbol
-        # These are NOT the statistics of the UTC day, but a 24hr rolling window for the previous 24hrs
-        # Update Speed 1000ms
+        # arrives one symbol dict or array of symbol dicts
         #
         #     {
         #         "e": "24hrTicker",      # event type
@@ -1060,34 +1101,14 @@ class binance(ccxt.async_support.binance):
         #         "n": 163222,            # total number of trades
         #     }
         #
-        event = self.safe_string(message, 'e', 'bookTicker')
-        if event == '24hrTicker':
-            event = 'ticker'
-        elif event == '24hrMiniTicker':
-            event = 'miniTicker'
-        wsMarketId = self.safe_string_lower(message, 's')
-        messageHash = wsMarketId + '@' + event
-        isSpot = ((client.url.find('/stream') > -1) or (client.url.find('/testnet.binance') > -1))
-        marketType = 'spot' if (isSpot) else 'contract'
-        result = self.parse_ws_ticker(message, marketType)
-        symbol = result['symbol']
-        self.tickers[symbol] = result
-        client.resolve(result, messageHash)
-        if event == 'bookTicker':
-            # watch bookTickers
-            client.resolve(result, '!' + 'bookTicker@arr')
-            messageHashes = self.find_message_hashes(client, 'tickers::')
-            for i in range(0, len(messageHashes)):
-                currentMessageHash = messageHashes[i]
-                parts = currentMessageHash.split('::')
-                symbolsString = parts[1]
-                symbols = symbolsString.split(',')
-                if self.in_array(symbol, symbols):
-                    client.resolve(result, currentMessageHash)
+        self.handle_tickers_and_bids_asks(client, message, 'tickers')
 
-    def handle_tickers(self, client: Client, message):
+    def handle_tickers_and_bids_asks(self, client: Client, message, methodType):
         isSpot = ((client.url.find('/stream') > -1) or (client.url.find('/testnet.binance') > -1))
         marketType = 'spot' if (isSpot) else 'contract'
+        isBidAsk = (methodType == 'bidasks')
+        channelName = None
+        resolvedMessageHashes = []
         rawTickers = []
         newTickers = {}
         if isinstance(message, list):
@@ -1096,22 +1117,34 @@ class binance(ccxt.async_support.binance):
             rawTickers.append(message)
         for i in range(0, len(rawTickers)):
             ticker = rawTickers[i]
-            result = self.parse_ws_ticker(ticker, marketType)
-            symbol = result['symbol']
-            self.tickers[symbol] = result
-            newTickers[symbol] = result
-        messageHashes = self.find_message_hashes(client, 'tickers::')
-        for i in range(0, len(messageHashes)):
-            messageHash = messageHashes[i]
-            parts = messageHash.split('::')
-            symbolsString = parts[1]
-            symbols = symbolsString.split(',')
-            tickers = self.filter_by_array(newTickers, 'symbol', symbols)
-            tickersSymbols = list(tickers.keys())
-            numTickers = len(tickersSymbols)
-            if numTickers > 0:
-                client.resolve(tickers, messageHash)
-        client.resolve(newTickers, 'tickers')
+            event = self.safe_string(ticker, 'e')
+            if isBidAsk:
+                event = 'bookTicker'  # in `handleMessage`, bookTicker doesn't have identifier, so manually set here
+            channelName = self.safe_string(self.options['tickerChannelsMap'], event, event)
+            if channelName is None:
+                continue
+            parsedTicker = self.parse_ws_ticker(ticker, marketType)
+            symbol = parsedTicker['symbol']
+            newTickers[symbol] = parsedTicker
+            if isBidAsk:
+                self.bidsasks[symbol] = parsedTicker
+            else:
+                self.tickers[symbol] = parsedTicker
+            messageHash = self.get_message_hash(channelName, symbol, isBidAsk)
+            resolvedMessageHashes.append(messageHash)
+            client.resolve(parsedTicker, messageHash)
+        # resolve batch endpoint
+        length = len(resolvedMessageHashes)
+        if length > 0:
+            batchMessageHash = self.get_message_hash(channelName, None, isBidAsk)
+            client.resolve(newTickers, batchMessageHash)
+
+    def get_message_hash(self, channelName: str, symbol: Str, isBidAsk: bool):
+        prefix = 'bidask' if isBidAsk else 'ticker'
+        if symbol is not None:
+            return prefix + ':' + channelName + '@' + symbol
+        else:
+            return prefix + 's' + ':' + channelName
 
     def sign_params(self, params={}):
         self.check_required_credentials()
@@ -2741,11 +2774,17 @@ class binance(ccxt.async_support.binance):
             'kline': self.handle_ohlcv,
             'markPrice_kline': self.handle_ohlcv,
             'indexPrice_kline': self.handle_ohlcv,
+            '1hTicker@arr': self.handle_tickers,
+            '4hTicker@arr': self.handle_tickers,
+            '1dTicker@arr': self.handle_tickers,
             '24hrTicker@arr': self.handle_tickers,
             '24hrMiniTicker@arr': self.handle_tickers,
-            '24hrTicker': self.handle_ticker,
-            '24hrMiniTicker': self.handle_ticker,
-            'bookTicker': self.handle_ticker,
+            '1hTicker': self.handle_tickers,
+            '4hTicker': self.handle_tickers,
+            '1dTicker': self.handle_tickers,
+            '24hrTicker': self.handle_tickers,
+            '24hrMiniTicker': self.handle_tickers,
+            'bookTicker': self.handle_bids_asks,  # there is no "bookTicker@arr" endpoint
             'outboundAccountPosition': self.handle_balance,
             'balanceUpdate': self.handle_balance,
             'ACCOUNT_UPDATE': self.handle_acount_update,
@@ -2773,8 +2812,7 @@ class binance(ccxt.async_support.binance):
             #         "A": "2.52500800"
             #     }
             #
-            if event is None:
-                self.handle_ticker(client, message)
-                self.handle_tickers(client, message)
+            if event is None and ('a' in message) and ('b' in message):
+                self.handle_bids_asks(client, message)
         else:
             method(client, message)

ccxt/pro/kucoin.py

@@ -824,17 +824,16 @@ class kucoin(ccxt.async_support.kucoin):
         return self.filter_by_symbol_since_limit(trades, symbol, since, limit, True)
 
     def handle_my_trade(self, client: Client, message):
-        trades = self.myTrades
-        if trades is None:
+        if self.myTrades is None:
             limit = self.safe_integer(self.options, 'tradesLimit', 1000)
-            trades = ArrayCacheBySymbolById(limit)
-        data = self.safe_value(message, 'data')
+            self.myTrades = ArrayCacheBySymbolById(limit)
+        data = self.safe_dict(message, 'data')
         parsed = self.parse_ws_trade(data)
-        trades.append(parsed)
+        self.myTrades.append(parsed)
         messageHash = 'myTrades'
-        client.resolve(trades, messageHash)
+        client.resolve(self.myTrades, messageHash)
         symbolSpecificMessageHash = messageHash + ':' + parsed['symbol']
-        client.resolve(trades, symbolSpecificMessageHash)
+        client.resolve(self.myTrades, symbolSpecificMessageHash)
 
     def parse_ws_trade(self, trade, market=None):
         #

ccxt/pro/okx.py

@@ -459,7 +459,7 @@ class okx(ccxt.async_support.okx):
         """
         watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
         :param str[] symbols: unified array of symbols
-        :param int [limit]: the maximum amount of order book entries to return
+        :param int [limit]: 1,5, 400, 50(l2-tbt, vip4+) or 40000(vip5+) 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
         """
@@ -467,6 +467,17 @@ class okx(ccxt.async_support.okx):
         symbols = self.market_symbols(symbols)
         options = self.safe_value(self.options, 'watchOrderBook', {})
         depth = self.safe_string(options, 'depth', 'books')
+        if limit is not None:
+            if limit == 1:
+                depth = 'bbo-tbt'
+            elif limit > 1 and limit <= 5:
+                depth = 'books5'
+            elif limit == 400:
+                depth = 'books'
+            elif limit == 50:
+                depth = 'books50-l2-tbt'  # Make sure you have VIP4 and above
+            elif limit == 4000:
+                depth = 'books-l2-tbt'  # Make sure you have VIP5 and above
         if (depth == 'books-l2-tbt') or (depth == 'books50-l2-tbt'):
             await self.authenticate({'access': 'public'})
         topics = []