ccxt 4.2.83 → 4.2.85

package/js/src/phemex.js

@@ -1298,7 +1298,7 @@ export default class phemex extends Exchange {
         //     }
         //
         const data = this.safeValue(response, 'data', {});
-        const rows = this.safeValue(data, 'rows', []);
+        const rows = this.safeList(data, 'rows', []);
         return this.parseOHLCVs(rows, market, timeframe, since, userLimit);
     }
     parseTicker(ticker, market = undefined) {
@@ -1461,7 +1461,7 @@ export default class phemex extends Exchange {
         //         }
         //     }
         //
-        const result = this.safeValue(response, 'result', {});
+        const result = this.safeDict(response, 'result', {});
         return this.parseTicker(result, market);
     }
     async fetchTickers(symbols = undefined, params = {}) {
@@ -1497,7 +1497,7 @@ export default class phemex extends Exchange {
         else {
             response = await this.v2GetMdV2Ticker24hrAll(query);
         }
-        const result = this.safeValue(response, 'result', []);
+        const result = this.safeList(response, 'result', []);
         return this.parseTickers(result, symbols);
     }
     async fetchTrades(symbol, since = undefined, limit = undefined, params = {}) {
@@ -2726,7 +2726,7 @@ export default class phemex extends Exchange {
         //         }
         //     }
         //
-        const data = this.safeValue(response, 'data', {});
+        const data = this.safeDict(response, 'data', {});
         return this.parseOrder(data, market);
     }
     async editOrder(id, symbol, type = undefined, side = undefined, amount = undefined, price = undefined, params = {}) {
@@ -2805,7 +2805,7 @@ export default class phemex extends Exchange {
         else {
             response = await this.privatePutSpotOrders(this.extend(request, params));
         }
-        const data = this.safeValue(response, 'data', {});
+        const data = this.safeDict(response, 'data', {});
         return this.parseOrder(data, market);
     }
     async cancelOrder(id, symbol = undefined, params = {}) {
@@ -2850,7 +2850,7 @@ export default class phemex extends Exchange {
         else {
             response = await this.privateDeleteSpotOrders(this.extend(request, params));
         }
-        const data = this.safeValue(response, 'data', {});
+        const data = this.safeDict(response, 'data', {});
         return this.parseOrder(data, market);
     }
     async cancelAllOrders(symbol = undefined, params = {}) {
@@ -2974,7 +2974,7 @@ export default class phemex extends Exchange {
             response = await this.privateGetSpotOrders(this.extend(request, params));
         }
         const data = this.safeValue(response, 'data', {});
-        const rows = this.safeValue(data, 'rows', data);
+        const rows = this.safeList(data, 'rows', data);
         return this.parseOrders(rows, market, since, limit);
     }
     async fetchOpenOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
@@ -3023,7 +3023,7 @@ export default class phemex extends Exchange {
             return this.parseOrders(data, market, since, limit);
         }
         else {
-            const rows = this.safeValue(data, 'rows', []);
+            const rows = this.safeList(data, 'rows', []);
             return this.parseOrders(rows, market, since, limit);
         }
     }
@@ -3110,7 +3110,7 @@ export default class phemex extends Exchange {
             return this.parseOrders(data, market, since, limit);
         }
         else {
-            const rows = this.safeValue(data, 'rows', []);
+            const rows = this.safeList(data, 'rows', []);
             return this.parseOrders(rows, market, since, limit);
         }
     }
@@ -4231,7 +4231,7 @@ export default class phemex extends Exchange {
         //
         //
         const data = this.safeValue(response, 'data', {});
-        const riskLimits = this.safeValue(data, 'riskLimits');
+        const riskLimits = this.safeList(data, 'riskLimits');
         return this.parseLeverageTiers(riskLimits, symbols, 'symbol');
     }
     parseMarketLeverageTiers(info, market = undefined) {
@@ -4493,7 +4493,7 @@ export default class phemex extends Exchange {
         //     }
         //
         const data = this.safeValue(response, 'data', {});
-        const transfers = this.safeValue(data, 'rows', []);
+        const transfers = this.safeList(data, 'rows', []);
         return this.parseTransfers(transfers, currency, since, limit);
     }
     parseTransfer(transfer, currency = undefined) {
@@ -4716,7 +4716,7 @@ export default class phemex extends Exchange {
         //         }
         //     }
         //
-        const data = this.safeValue(response, 'data', {});
+        const data = this.safeDict(response, 'data', {});
         return this.parseTransaction(data, currency);
     }
     handleErrors(httpCode, reason, url, method, headers, body, response, requestHeaders, requestBody) {

package/js/src/poloniexfutures.js

@@ -679,7 +679,7 @@ export default class poloniexfutures extends Exchange {
         //        },
         //    }
         //
-        const trades = this.safeValue(response, 'data', []);
+        const trades = this.safeList(response, 'data', []);
         return this.parseTrades(trades, market, since, limit);
     }
     async fetchTime(params = {}) {
@@ -752,7 +752,7 @@ export default class poloniexfutures extends Exchange {
         //        ]
         //    }
         //
-        const data = this.safeValue(response, 'data', []);
+        const data = this.safeList(response, 'data', []);
         return this.parseOHLCVs(data, market, timeframe, since, limit);
     }
     parseBalance(response) {
@@ -1012,7 +1012,7 @@ export default class poloniexfutures extends Exchange {
         //        ]
         //    }
         //
-        const data = this.safeValue(response, 'data');
+        const data = this.safeList(response, 'data');
         return this.parsePositions(data, symbols);
     }
     parsePosition(position, market = undefined) {
@@ -1466,7 +1466,7 @@ export default class poloniexfutures extends Exchange {
         //    }
         //
         const market = (symbol !== undefined) ? this.market(symbol) : undefined;
-        const responseData = this.safeValue(response, 'data');
+        const responseData = this.safeDict(response, 'data');
         return this.parseOrder(responseData, market);
     }
     parseOrder(order, market = undefined) {
@@ -1702,7 +1702,7 @@ export default class poloniexfutures extends Exchange {
         //    }
         //
         const data = this.safeValue(response, 'data', {});
-        const trades = this.safeValue(data, 'items', {});
+        const trades = this.safeList(data, 'items', []);
         return this.parseTrades(trades, market, since, limit);
     }
     async setMarginMode(marginMode, symbol = undefined, params = {}) {

package/js/src/pro/binance.d.ts

@@ -24,9 +24,13 @@ export default class binance extends binanceRest {
     handleFetchOHLCV(client: Client, message: any): void;
     watchTicker(symbol: string, params?: {}): Promise<Ticker>;
     watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
+    watchBidsAsks(symbols?: Strings, params?: {}): Promise<Tickers>;
+    watchMultiTickerHelper(methodName: any, channelName: string, symbols?: Strings, params?: {}): Promise<any>;
     parseWsTicker(message: any, marketType: any): Ticker;
-    handleTicker(client: Client, message: any): void;
+    handleBidsAsks(client: Client, message: any): void;
     handleTickers(client: Client, message: any): void;
+    handleTickersAndBidsAsks(client: Client, message: any, methodType: any): void;
+    getMessageHash(channelName: string, symbol: Str, isBidAsk: boolean): string;
     signParams(params?: {}): any;
     authenticate(params?: {}): Promise<void>;
     keepAliveListenKey(params?: {}): Promise<void>;

package/js/src/pro/binance.js

@@ -7,7 +7,7 @@
 // ----------------------------------------------------------------------------
 import binanceRest from '../binance.js';
 import { Precise } from '../base/Precise.js';
-import { ExchangeError, ArgumentsRequired, BadRequest } from '../base/errors.js';
+import { ExchangeError, ArgumentsRequired, BadRequest, NotSupported } from '../base/errors.js';
 import { ArrayCache, ArrayCacheByTimestamp, ArrayCacheBySymbolById, ArrayCacheBySymbolBySide } from '../base/ws/Cache.js';
 import { sha256 } from '../static_dependencies/noble-hashes/sha256.js';
 import { rsa } from '../base/functions/rsa.js';
@@ -20,6 +20,7 @@ export default class binance extends binanceRest {
             'has': {
                 'ws': true,
                 'watchBalance': true,
+                'watchBidsAsks': true,
                 'watchMyTrades': true,
                 'watchOHLCV': true,
                 'watchOHLCVForSymbols': false,
@@ -101,10 +102,10 @@ export default class binance extends binanceRest {
                     '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)
@@ -125,6 +126,15 @@ export default class binance extends binanceRest {
                 'ws': {
                     'cost': 5,
                 },
+                'tickerChannelsMap': {
+                    '24hrTicker': 'ticker',
+                    '24hrMiniTicker': 'miniTicker',
+                    // rolling window tickers
+                    '1hTicker': 'ticker_1h',
+                    '4hTicker': 'ticker_4h',
+                    '1dTicker': 'ticker_1d',
+                    'bookTicker': 'bookTicker',
+                },
             },
         });
     }
@@ -938,34 +948,13 @@ export default class binance extends binanceRest {
          * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
          * @param {string} symbol unified symbol of the market to fetch the ticker for
          * @param {object} [params] extra parameters specific to the exchange API endpoint
-         * @param {string} [params.name] stream to use can be ticker or bookTicker
+         * @param {string} [params.name] stream to use can be ticker or miniTicker
          * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
          */
         await this.loadMarkets();
-        const market = this.market(symbol);
-        const marketId = market['lowercaseId'];
-        let type = market['type'];
-        if (market['contract']) {
-            type = market['linear'] ? 'future' : 'delivery';
-        }
-        const options = this.safeValue(this.options, 'watchTicker', {});
-        let name = this.safeString(options, 'name', 'ticker');
-        name = this.safeString(params, 'name', name);
-        params = this.omit(params, 'name');
-        const messageHash = marketId + '@' + name;
-        const url = this.urls['api']['ws'][type] + '/' + this.stream(type, messageHash);
-        const requestId = this.requestId(url);
-        const request = {
-            'method': 'SUBSCRIBE',
-            'params': [
-                messageHash,
-            ],
-            'id': requestId,
-        };
-        const subscribe = {
-            'id': requestId,
-        };
-        return await this.watch(url, messageHash, this.extend(request, params), messageHash, subscribe);
+        symbol = this.symbol(symbol);
+        const tickers = await this.watchTickers([symbol], this.extend(params, { 'callerMethodName': 'watchTicker' }));
+        return tickers[symbol];
     }
     async watchTickers(symbols = undefined, params = {}) {
         /**
@@ -976,61 +965,108 @@ export default class binance extends binanceRest {
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
          */
-        await this.loadMarkets();
-        symbols = this.marketSymbols(symbols, undefined, true, true, true);
-        const marketIds = this.marketIds(symbols);
-        let market = undefined;
-        let type = undefined;
-        if (symbols !== undefined) {
-            market = this.market(symbols[0]);
+        let channelName = undefined;
+        [channelName, params] = this.handleOptionAndParams(params, 'watchTickers', 'name', 'ticker');
+        if (channelName === 'bookTicker') {
+            throw new BadRequest(this.id + ' deprecation notice - to subscribe for bids-asks, use watch_bids_asks() method instead');
         }
-        [type, params] = this.handleMarketTypeAndParams('watchTickers', market, params);
+        const newTickers = await this.watchMultiTickerHelper('watchTickers', channelName, symbols, params);
+        if (this.newUpdates) {
+            return newTickers;
+        }
+        return this.filterByArray(this.tickers, 'symbol', symbols);
+    }
+    async watchBidsAsks(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name binance#watchBidsAsks
+         * @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
+         * @description watches best bid & ask for symbols
+         * @param {string[]} symbols unified symbol of the market to fetch the ticker for
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+         */
+        const result = await this.watchMultiTickerHelper('watchBidsAsks', 'bookTicker', symbols, params);
+        if (this.newUpdates) {
+            return result;
+        }
+        return this.filterByArray(this.tickers, 'symbol', symbols);
+    }
+    async watchMultiTickerHelper(methodName, channelName, symbols = undefined, params = {}) {
+        await this.loadMarkets();
+        symbols = this.marketSymbols(symbols, undefined, true, false, true);
+        let firstMarket = undefined;
+        let marketType = undefined;
+        const symbolsDefined = (symbols !== undefined);
+        if (symbolsDefined) {
+            firstMarket = this.market(symbols[0]);
+        }
+        [marketType, params] = this.handleMarketTypeAndParams(methodName, firstMarket, params);
         let subType = undefined;
-        [subType, params] = this.handleSubTypeAndParams('watchTickers', market, params);
-        if (this.isLinear(type, subType)) {
-            type = 'future';
+        [subType, params] = this.handleSubTypeAndParams(methodName, firstMarket, params);
+        let rawMarketType = undefined;
+        if (this.isLinear(marketType, subType)) {
+            rawMarketType = 'future';
         }
-        else if (this.isInverse(type, subType)) {
-            type = 'delivery';
+        else if (this.isInverse(marketType, subType)) {
+            rawMarketType = 'delivery';
         }
-        const options = this.safeValue(this.options, 'watchTickers', {});
-        let name = this.safeString(options, 'name', 'ticker');
-        name = this.safeString(params, 'name', name);
-        params = this.omit(params, 'name');
-        let wsParams = [];
-        let messageHash = 'tickers';
-        if (symbols !== undefined) {
-            messageHash = 'tickers::' + symbols.join(',');
+        else if (marketType === 'spot') {
+            rawMarketType = marketType;
         }
-        if (name === 'bookTicker') {
-            if (marketIds === undefined) {
-                throw new ArgumentsRequired(this.id + ' watchTickers() requires symbols for bookTicker');
-            }
-            // simulate watchTickers with subscribe multiple individual bookTicker topic
-            for (let i = 0; i < marketIds.length; i++) {
-                wsParams.push(marketIds[i].toLowerCase() + '@bookTicker');
+        else {
+            throw new NotSupported(this.id + ' ' + methodName + '() does not support options markets');
+        }
+        const isBidAsk = (channelName === 'bookTicker');
+        const subscriptionArgs = [];
+        const messageHashes = [];
+        if (symbolsDefined) {
+            for (let i = 0; i < symbols.length; i++) {
+                const symbol = symbols[i];
+                const market = this.market(symbol);
+                subscriptionArgs.push(market['lowercaseId'] + '@' + channelName);
+                messageHashes.push(this.getMessageHash(channelName, market['symbol'], isBidAsk));
             }
         }
         else {
-            wsParams = [
-                '!' + name + '@arr',
-            ];
+            if (isBidAsk) {
+                if (marketType === 'spot') {
+                    throw new ArgumentsRequired(this.id + ' ' + methodName + '() requires symbols for this channel for spot markets');
+                }
+                subscriptionArgs.push('!' + channelName);
+            }
+            else {
+                subscriptionArgs.push('!' + channelName + '@arr');
+            }
+            messageHashes.push(this.getMessageHash(channelName, undefined, isBidAsk));
         }
-        const url = this.urls['api']['ws'][type] + '/' + this.stream(type, messageHash);
+        let streamHash = channelName;
+        if (symbolsDefined) {
+            streamHash = channelName + '::' + symbols.join(',');
+        }
+        const url = this.urls['api']['ws'][rawMarketType] + '/' + this.stream(rawMarketType, streamHash);
         const requestId = this.requestId(url);
         const request = {
             'method': 'SUBSCRIBE',
-            'params': wsParams,
+            'params': subscriptionArgs,
             'id': requestId,
         };
         const subscribe = {
             'id': requestId,
         };
-        const newTickers = await this.watch(url, messageHash, this.extend(request, params), messageHash, subscribe);
-        if (this.newUpdates) {
-            return newTickers;
+        const result = await this.watchMultiple(url, messageHashes, this.deepExtend(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 (!symbolsDefined) {
+            return result;
+        }
+        else {
+            const newDict = {};
+            newDict[result['symbol']] = result;
+            return newDict;
         }
-        return this.filterByArray(this.tickers, 'symbol', symbols);
     }
     parseWsTicker(message, marketType) {
         //
@@ -1114,11 +1150,24 @@ export default class binance extends binanceRest {
             'info': message,
         }, market);
     }
-    handleTicker(client, message) {
+    handleBidsAsks(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"
+        //     }
+        //
+        this.handleTickersAndBidsAsks(client, message, 'bidasks');
+    }
+    handleTickers(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
@@ -1146,39 +1195,14 @@ export default class binance extends binanceRest {
         //         "n": 163222,            // total number of trades
         //     }
         //
-        let event = this.safeString(message, 'e', 'bookTicker');
-        if (event === '24hrTicker') {
-            event = 'ticker';
-        }
-        else if (event === '24hrMiniTicker') {
-            event = 'miniTicker';
-        }
-        const wsMarketId = this.safeStringLower(message, 's');
-        const messageHash = wsMarketId + '@' + event;
-        const isSpot = ((client.url.indexOf('/stream') > -1) || (client.url.indexOf('/testnet.binance') > -1));
-        const marketType = (isSpot) ? 'spot' : 'contract';
-        const result = this.parseWsTicker(message, marketType);
-        const symbol = result['symbol'];
-        this.tickers[symbol] = result;
-        client.resolve(result, messageHash);
-        if (event === 'bookTicker') {
-            // watch bookTickers
-            client.resolve(result, '!' + 'bookTicker@arr');
-            const messageHashes = this.findMessageHashes(client, 'tickers::');
-            for (let i = 0; i < messageHashes.length; i++) {
-                const currentMessageHash = messageHashes[i];
-                const parts = currentMessageHash.split('::');
-                const symbolsString = parts[1];
-                const symbols = symbolsString.split(',');
-                if (this.inArray(symbol, symbols)) {
-                    client.resolve(result, currentMessageHash);
-                }
-            }
-        }
+        this.handleTickersAndBidsAsks(client, message, 'tickers');
     }
-    handleTickers(client, message) {
+    handleTickersAndBidsAsks(client, message, methodType) {
         const isSpot = ((client.url.indexOf('/stream') > -1) || (client.url.indexOf('/testnet.binance') > -1));
         const marketType = (isSpot) ? 'spot' : 'contract';
+        const isBidAsk = (methodType === 'bidasks');
+        let channelName = undefined;
+        const resolvedMessageHashes = [];
         let rawTickers = [];
         const newTickers = {};
         if (Array.isArray(message)) {
@@ -1189,25 +1213,42 @@ export default class binance extends binanceRest {
         }
         for (let i = 0; i < rawTickers.length; i++) {
             const ticker = rawTickers[i];
-            const result = this.parseWsTicker(ticker, marketType);
-            const symbol = result['symbol'];
-            this.tickers[symbol] = result;
-            newTickers[symbol] = result;
-        }
-        const messageHashes = this.findMessageHashes(client, 'tickers::');
-        for (let i = 0; i < messageHashes.length; i++) {
-            const messageHash = messageHashes[i];
-            const parts = messageHash.split('::');
-            const symbolsString = parts[1];
-            const symbols = symbolsString.split(',');
-            const tickers = this.filterByArray(newTickers, 'symbol', symbols);
-            const tickersSymbols = Object.keys(tickers);
-            const numTickers = tickersSymbols.length;
-            if (numTickers > 0) {
-                client.resolve(tickers, messageHash);
+            let event = this.safeString(ticker, 'e');
+            if (isBidAsk) {
+                event = 'bookTicker'; // as noted in `handleMessage`, bookTicker doesn't have identifier, so manually set here
+            }
+            channelName = this.safeString(this.options['tickerChannelsMap'], event, event);
+            if (channelName === undefined) {
+                continue;
+            }
+            const parsedTicker = this.parseWsTicker(ticker, marketType);
+            const symbol = parsedTicker['symbol'];
+            newTickers[symbol] = parsedTicker;
+            if (isBidAsk) {
+                this.bidsasks[symbol] = parsedTicker;
+            }
+            else {
+                this.tickers[symbol] = parsedTicker;
             }
+            const messageHash = this.getMessageHash(channelName, symbol, isBidAsk);
+            resolvedMessageHashes.push(messageHash);
+            client.resolve(parsedTicker, messageHash);
+        }
+        // resolve batch endpoint
+        const length = resolvedMessageHashes.length;
+        if (length > 0) {
+            const batchMessageHash = this.getMessageHash(channelName, undefined, isBidAsk);
+            client.resolve(newTickers, batchMessageHash);
+        }
+    }
+    getMessageHash(channelName, symbol, isBidAsk) {
+        const prefix = isBidAsk ? 'bidask' : 'ticker';
+        if (symbol !== undefined) {
+            return prefix + ':' + channelName + '@' + symbol;
+        }
+        else {
+            return prefix + 's' + ':' + channelName;
         }
-        client.resolve(newTickers, 'tickers');
     }
     signParams(params = {}) {
         this.checkRequiredCredentials();
@@ -3012,11 +3053,17 @@ export default class binance extends binanceRest {
             'kline': this.handleOHLCV,
             'markPrice_kline': this.handleOHLCV,
             'indexPrice_kline': this.handleOHLCV,
+            '1hTicker@arr': this.handleTickers,
+            '4hTicker@arr': this.handleTickers,
+            '1dTicker@arr': this.handleTickers,
             '24hrTicker@arr': this.handleTickers,
             '24hrMiniTicker@arr': this.handleTickers,
-            '24hrTicker': this.handleTicker,
-            '24hrMiniTicker': this.handleTicker,
-            'bookTicker': this.handleTicker,
+            '1hTicker': this.handleTickers,
+            '4hTicker': this.handleTickers,
+            '1dTicker': this.handleTickers,
+            '24hrTicker': this.handleTickers,
+            '24hrMiniTicker': this.handleTickers,
+            'bookTicker': this.handleBidsAsks,
             'outboundAccountPosition': this.handleBalance,
             'balanceUpdate': this.handleBalance,
             'ACCOUNT_UPDATE': this.handleAcountUpdate,
@@ -3046,9 +3093,8 @@ export default class binance extends binanceRest {
             //         "A": "2.52500800"
             //     }
             //
-            if (event === undefined) {
-                this.handleTicker(client, message);
-                this.handleTickers(client, message);
+            if (event === undefined && ('a' in message) && ('b' in message)) {
+                this.handleBidsAsks(client, message);
             }
         }
         else {

package/js/src/pro/kucoin.js

@@ -890,18 +890,17 @@ export default class kucoin extends kucoinRest {
         return this.filterBySymbolSinceLimit(trades, symbol, since, limit, true);
     }
     handleMyTrade(client, message) {
-        let trades = this.myTrades;
-        if (trades === undefined) {
+        if (this.myTrades === undefined) {
             const limit = this.safeInteger(this.options, 'tradesLimit', 1000);
-            trades = new ArrayCacheBySymbolById(limit);
+            this.myTrades = new ArrayCacheBySymbolById(limit);
         }
-        const data = this.safeValue(message, 'data');
+        const data = this.safeDict(message, 'data');
         const parsed = this.parseWsTrade(data);
-        trades.append(parsed);
+        this.myTrades.append(parsed);
         const messageHash = 'myTrades';
-        client.resolve(trades, messageHash);
+        client.resolve(this.myTrades, messageHash);
         const symbolSpecificMessageHash = messageHash + ':' + parsed['symbol'];
-        client.resolve(trades, symbolSpecificMessageHash);
+        client.resolve(this.myTrades, symbolSpecificMessageHash);
     }
     parseWsTrade(trade, market = undefined) {
         //

package/js/src/pro/okx.js

@@ -490,14 +490,31 @@ export default class okx extends okxRest {
          * @name okx#watchOrderBookForSymbols
          * @description watches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
          * @param {string[]} 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 {object} [params] extra parameters specific to the exchange API endpoint
          * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
          */
         await this.loadMarkets();
         symbols = this.marketSymbols(symbols);
         const options = this.safeValue(this.options, 'watchOrderBook', {});
-        const depth = this.safeString(options, 'depth', 'books');
+        let depth = this.safeString(options, 'depth', 'books');
+        if (limit !== undefined) {
+            if (limit === 1) {
+                depth = 'bbo-tbt';
+            }
+            else if (limit > 1 && limit <= 5) {
+                depth = 'books5';
+            }
+            else if (limit === 400) {
+                depth = 'books';
+            }
+            else if (limit === 50) {
+                depth = 'books50-l2-tbt'; // Make sure you have VIP4 and above
+            }
+            else if (limit === 4000) {
+                depth = 'books-l2-tbt'; // Make sure you have VIP5 and above
+            }
+        }
         if ((depth === 'books-l2-tbt') || (depth === 'books50-l2-tbt')) {
             await this.authenticate({ 'access': 'public' });
         }