ccxt 4.2.84 → 4.2.86

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/bitget.js

@@ -86,6 +86,7 @@ export default class bitget extends bitgetRest {
                         '30015': AuthenticationError,
                         '30016': BadRequest, // { event: 'error', code: 30016, msg: 'Param error' }
                     },
+                    'broad': {},
                 },
             },
         });

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' });
         }

package/js/src/probit.js

@@ -624,7 +624,7 @@ export default class probit extends Exchange {
         //         ]
         //     }
         //
-        const data = this.safeValue(response, 'data', []);
+        const data = this.safeList(response, 'data', []);
         return this.parseTickers(data, symbols);
     }
     async fetchTicker(symbol, params = {}) {
@@ -760,7 +760,7 @@ export default class probit extends Exchange {
         //         ]
         //     }
         //
-        const data = this.safeValue(response, 'data', []);
+        const data = this.safeList(response, 'data', []);
         return this.parseTrades(data, market, since, limit);
     }
     async fetchTrades(symbol, since = undefined, limit = undefined, params = {}) {
@@ -814,7 +814,7 @@ export default class probit extends Exchange {
         //         ]
         //     }
         //
-        const data = this.safeValue(response, 'data', []);
+        const data = this.safeList(response, 'data', []);
         return this.parseTrades(data, market, since, limit);
     }
     parseTrade(trade, market = undefined) {
@@ -1002,7 +1002,7 @@ export default class probit extends Exchange {
         //         ]
         //     }
         //
-        const data = this.safeValue(response, 'data', []);
+        const data = this.safeList(response, 'data', []);
         return this.parseOHLCVs(data, market, timeframe, since, limit);
     }
     parseOHLCV(ohlcv, market = undefined) {
@@ -1049,7 +1049,7 @@ export default class probit extends Exchange {
             request['market_id'] = market['id'];
         }
         const response = await this.privateGetOpenOrder(this.extend(request, params));
-        const data = this.safeValue(response, 'data');
+        const data = this.safeList(response, 'data');
         return this.parseOrders(data, market, since, limit);
     }
     async fetchClosedOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
@@ -1082,7 +1082,7 @@ export default class probit extends Exchange {
             request['limit'] = limit;
         }
         const response = await this.privateGetOrderHistory(this.extend(request, params));
-        const data = this.safeValue(response, 'data');
+        const data = this.safeList(response, 'data');
         return this.parseOrders(data, market, since, limit);
     }
     async fetchOrder(id, symbol = undefined, params = {}) {
@@ -1113,7 +1113,7 @@ export default class probit extends Exchange {
         const query = this.omit(params, ['clientOrderId', 'client_order_id']);
         const response = await this.privateGetOrder(this.extend(request, query));
         const data = this.safeValue(response, 'data', []);
-        const order = this.safeValue(data, 0);
+        const order = this.safeDict(data, 0);
         return this.parseOrder(order, market);
     }
     parseOrderStatus(status) {
@@ -1312,7 +1312,7 @@ export default class probit extends Exchange {
             'order_id': id,
         };
         const response = await this.privatePostCancelOrder(this.extend(request, params));
-        const data = this.safeValue(response, 'data');
+        const data = this.safeDict(response, 'data');
         return this.parseOrder(data);
     }
     parseDepositAddress(depositAddress, currency = undefined) {
@@ -1406,7 +1406,7 @@ export default class probit extends Exchange {
             request['currency_id'] = codes.join(',');
         }
         const response = await this.privateGetDepositAddress(this.extend(request, params));
-        const data = this.safeValue(response, 'data', []);
+        const data = this.safeList(response, 'data', []);
         return this.parseDepositAddresses(data, codes);
     }
     async withdraw(code, amount, address, tag = undefined, params = {}) {
@@ -1453,7 +1453,7 @@ export default class probit extends Exchange {
             params = this.omit(params, 'network');
         }
         const response = await this.privatePostWithdrawal(this.extend(request, params));
-        const data = this.safeValue(response, 'data');
+        const data = this.safeDict(response, 'data');
         return this.parseTransaction(data, currency);
     }
     async fetchDeposits(code = undefined, since = undefined, limit = undefined, params = {}) {
@@ -1703,7 +1703,7 @@ export default class probit extends Exchange {
         //     ]
         //  }
         //
-        const data = this.safeValue(response, 'data');
+        const data = this.safeList(response, 'data');
         return this.parseDepositWithdrawFees(data, codes, 'id');
     }
     parseDepositWithdrawFee(fee, currency = undefined) {

package/js/src/timex.js

@@ -549,7 +549,7 @@ export default class timex extends Exchange {
         //         }
         //     ]
         //
-        const ticker = this.safeValue(response, 0);
+        const ticker = this.safeDict(response, 0);
         return this.parseTicker(ticker, market);
     }
     async fetchOrderBook(symbol, limit = undefined, params = {}) {
@@ -810,7 +810,7 @@ export default class timex extends Exchange {
         //     }
         //
         const orders = this.safeValue(response, 'orders', []);
-        const order = this.safeValue(orders, 0, {});
+        const order = this.safeDict(orders, 0, {});
         return this.parseOrder(order, market);
     }
     async editOrder(id, symbol, type, side, amount = undefined, price = undefined, params = {}) {
@@ -861,7 +861,7 @@ export default class timex extends Exchange {
         }
         const orders = this.safeValue(response, 'changedOrders', []);
         const firstOrder = this.safeValue(orders, 0, {});
-        const order = this.safeValue(firstOrder, 'newOrder', {});
+        const order = this.safeDict(firstOrder, 'newOrder', {});
         return this.parseOrder(order, market);
     }
     async cancelOrder(id, symbol = undefined, params = {}) {
@@ -969,7 +969,7 @@ export default class timex extends Exchange {
         //     }
         //
         const order = this.safeValue(response, 'order', {});
-        const trades = this.safeValue(response, 'trades', []);
+        const trades = this.safeList(response, 'trades', []);
         return this.parseOrder(this.extend(order, { 'trades': trades }));
     }
     async fetchOpenOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
@@ -1024,7 +1024,7 @@ export default class timex extends Exchange {
         //         ]
         //     }
         //
-        const orders = this.safeValue(response, 'orders', []);
+        const orders = this.safeList(response, 'orders', []);
         return this.parseOrders(orders, market, since, limit);
     }
     async fetchClosedOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
@@ -1084,7 +1084,7 @@ export default class timex extends Exchange {
         //         ]
         //     }
         //
-        const orders = this.safeValue(response, 'orders', []);
+        const orders = this.safeList(response, 'orders', []);
         return this.parseOrders(orders, market, since, limit);
     }
     async fetchMyTrades(symbol = undefined, since = undefined, limit = undefined, params = {}) {
@@ -1147,7 +1147,7 @@ export default class timex extends Exchange {
         //         ]
         //     }
         //
-        const trades = this.safeValue(response, 'trades', []);
+        const trades = this.safeList(response, 'trades', []);
         return this.parseTrades(trades, market, since, limit);
     }
     parseTradingFee(fee, market = undefined) {