ccxt 4.3.40 → 4.3.42

package/js/src/pro/bingx.js

@@ -6,7 +6,7 @@
 
 //  ---------------------------------------------------------------------------
 import bingxRest from '../bingx.js';
-import { BadRequest, NetworkError } from '../base/errors.js';
+import { BadRequest, NetworkError, NotSupported, ArgumentsRequired } from '../base/errors.js';
 import { ArrayCache, ArrayCacheByTimestamp, ArrayCacheBySymbolById } from '../base/ws/Cache.js';
 import { Precise } from '../base/Precise.js';
 //  ---------------------------------------------------------------------------
@@ -17,11 +17,13 @@ export default class bingx extends bingxRest {
                 'ws': true,
                 'watchTrades': true,
                 'watchOrderBook': true,
+                'watchOrderBookForSymbols': true,
                 'watchOHLCV': true,
+                'watchOHLCVForSymbols': true,
                 'watchOrders': true,
                 'watchMyTrades': true,
                 'watchTicker': true,
-                'watchTickers': false,
+                'watchTickers': true,
                 'watchBalance': true,
             },
             'urls': {
@@ -69,6 +71,14 @@ export default class bingx extends bingxRest {
                     'fetchBalanceSnapshot': true,
                     'awaitBalanceSnapshot': false, // whether to wait for the balance snapshot before providing updates
                 },
+                'watchOrderBook': {
+                    'depth': 100,
+                    'interval': 500, // 100, 200, 500, 1000
+                },
+                'watchOrderBookForSymbols': {
+                    'depth': 100,
+                    'interval': 500, // 100, 200, 500, 1000
+                },
             },
             'streaming': {
                 'keepAlive': 1800000, // 30 minutes
@@ -92,16 +102,17 @@ export default class bingx extends bingxRest {
         if (url === undefined) {
             throw new BadRequest(this.id + ' watchTrades is not supported for ' + marketType + ' markets.');
         }
-        const messageHash = market['id'] + '@ticker';
+        const subscriptionHash = market['id'] + '@ticker';
+        const messageHash = this.getMessageHash('ticker', market['symbol']);
         const uuid = this.uuid();
         const request = {
             'id': uuid,
-            'dataType': messageHash,
+            'dataType': subscriptionHash,
         };
         if (marketType === 'swap') {
             request['reqType'] = 'sub';
         }
-        return await this.watch(url, messageHash, this.extend(request, query), messageHash);
+        return await this.watch(url, messageHash, this.extend(request, query), subscriptionHash);
     }
     handleTicker(client, message) {
         //
@@ -167,8 +178,10 @@ export default class bingx extends bingxRest {
         const symbol = market['symbol'];
         const ticker = this.parseWsTicker(data, market);
         this.tickers[symbol] = ticker;
-        const messageHash = market['id'] + '@ticker';
-        client.resolve(ticker, messageHash);
+        client.resolve(ticker, this.getMessageHash('ticker', symbol));
+        if (this.safeString(message, 'dataType') === 'all@ticker') {
+            client.resolve(ticker, this.getMessageHash('ticker'));
+        }
     }
     parseWsTicker(message, market = undefined) {
         //
@@ -220,6 +233,206 @@ export default class bingx extends bingxRest {
             'info': message,
         }, market);
     }
+    async watchTickers(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name bingx#watchTickers
+         * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
+         * @see https://bingx-api.github.io/docs/#/en-us/swapV2/socket/market.html#Subscribe%20to%2024-hour%20price%20changes%20of%20all%20trading%20pairs
+         * @param {string[]} symbols unified symbol of the market to watch the tickers 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}
+         */
+        await this.loadMarkets();
+        symbols = this.marketSymbols(symbols, undefined, true, true, false);
+        let firstMarket = undefined;
+        let marketType = undefined;
+        const symbolsDefined = (symbols !== undefined);
+        if (symbolsDefined) {
+            firstMarket = this.market(symbols[0]);
+        }
+        [marketType, params] = this.handleMarketTypeAndParams('watchTickers', firstMarket, params);
+        if (marketType === 'spot') {
+            throw new NotSupported(this.id + ' watchTickers is not supported for spot markets yet');
+        }
+        const messageHashes = [];
+        const subscriptionHashes = ['all@ticker'];
+        if (symbolsDefined) {
+            for (let i = 0; i < symbols.length; i++) {
+                const symbol = symbols[i];
+                const market = this.market(symbol);
+                messageHashes.push(this.getMessageHash('ticker', market['symbol']));
+            }
+        }
+        else {
+            messageHashes.push(this.getMessageHash('ticker'));
+        }
+        const url = this.safeString(this.urls['api']['ws'], marketType);
+        const uuid = this.uuid();
+        const request = {
+            'id': uuid,
+            'dataType': 'all@ticker',
+        };
+        if (marketType === 'swap') {
+            request['reqType'] = 'sub';
+        }
+        const result = await this.watchMultiple(url, messageHashes, this.deepExtend(request, params), subscriptionHashes);
+        if (this.newUpdates) {
+            const newDict = {};
+            newDict[result['symbol']] = result;
+            return newDict;
+        }
+        return this.tickers;
+    }
+    async watchOrderBookForSymbols(symbols, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name bingx#watchOrderBookForSymbols
+         * @description watches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
+         * @see https://bingx-api.github.io/docs/#/en-us/swapV2/socket/market.html#Subscribe%20Market%20Depth%20Data%20of%20all%20trading%20pairs
+         * @param {string[]} symbols unified array of symbols
+         * @param {int} [limit] 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
+         */
+        symbols = this.marketSymbols(symbols, undefined, true, true, false);
+        let firstMarket = undefined;
+        let marketType = undefined;
+        const symbolsDefined = (symbols !== undefined);
+        if (symbolsDefined) {
+            firstMarket = this.market(symbols[0]);
+        }
+        [marketType, params] = this.handleMarketTypeAndParams('watchOrderBookForSymbols', firstMarket, params);
+        if (marketType === 'spot') {
+            throw new NotSupported(this.id + ' watchOrderBookForSymbols is not supported for spot markets yet');
+        }
+        limit = this.getOrderBookLimitByMarketType(marketType, limit);
+        let interval = undefined;
+        [interval, params] = this.handleOptionAndParams(params, 'watchOrderBookForSymbols', 'interval', 500);
+        this.checkRequiredArgument('watchOrderBookForSymbols', interval, 'interval', [100, 200, 500, 1000]);
+        const channelName = 'depth' + limit.toString() + '@' + interval.toString() + 'ms';
+        const subscriptionHash = 'all@' + channelName;
+        const messageHashes = [];
+        if (symbolsDefined) {
+            for (let i = 0; i < symbols.length; i++) {
+                const symbol = symbols[i];
+                const market = this.market(symbol);
+                messageHashes.push(this.getMessageHash('orderbook', market['symbol']));
+            }
+        }
+        else {
+            messageHashes.push(this.getMessageHash('orderbook'));
+        }
+        const url = this.safeString(this.urls['api']['ws'], marketType);
+        const uuid = this.uuid();
+        const request = {
+            'id': uuid,
+            'dataType': subscriptionHash,
+        };
+        if (marketType === 'swap') {
+            request['reqType'] = 'sub';
+        }
+        const subscriptionArgs = {
+            'symbols': symbols,
+            'limit': limit,
+            'interval': interval,
+            'params': params,
+        };
+        const orderbook = await this.watchMultiple(url, messageHashes, this.deepExtend(request, params), [subscriptionHash], subscriptionArgs);
+        return orderbook.limit();
+    }
+    async watchOHLCVForSymbols(symbolsAndTimeframes, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name bingx#watchOHLCVForSymbols
+         * @description watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+         * @param {string[][]} 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 {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
+         */
+        const symbolsLength = symbolsAndTimeframes.length;
+        if (symbolsLength !== 0 && !Array.isArray(symbolsAndTimeframes[0])) {
+            throw new ArgumentsRequired(this.id + " watchOHLCVForSymbols() requires a an array like  [['BTC/USDT:USDT', '1m'], ['LTC/USDT:USDT', '5m']]");
+        }
+        await this.loadMarkets();
+        const messageHashes = [];
+        let marketType = undefined;
+        let chosenTimeframe = undefined;
+        if (symbolsLength !== 0) {
+            let symbols = this.getListFromObjectValues(symbolsAndTimeframes, 0);
+            symbols = this.marketSymbols(symbols, undefined, true, true, false);
+            const firstMarket = this.market(symbols[0]);
+            [marketType, params] = this.handleMarketTypeAndParams('watchOrderBookForSymbols', firstMarket, params);
+            if (marketType === 'spot') {
+                throw new NotSupported(this.id + ' watchOrderBookForSymbols is not supported for spot markets yet');
+            }
+        }
+        const marketOptions = this.safeDict(this.options, marketType);
+        const timeframes = this.safeDict(marketOptions, 'timeframes', {});
+        for (let i = 0; i < symbolsAndTimeframes.length; i++) {
+            const symbolAndTimeframe = symbolsAndTimeframes[i];
+            const sym = symbolAndTimeframe[0];
+            const tf = symbolAndTimeframe[1];
+            const market = this.market(sym);
+            const rawTimeframe = this.safeString(timeframes, tf, tf);
+            if (chosenTimeframe === undefined) {
+                chosenTimeframe = rawTimeframe;
+            }
+            else if (chosenTimeframe !== rawTimeframe) {
+                throw new BadRequest(this.id + ' watchOHLCVForSymbols requires all timeframes to be the same');
+            }
+            messageHashes.push(this.getMessageHash('ohlcv', market['symbol'], chosenTimeframe));
+        }
+        const subscriptionHash = 'all@kline_' + chosenTimeframe;
+        const url = this.safeString(this.urls['api']['ws'], marketType);
+        const uuid = this.uuid();
+        const request = {
+            'id': uuid,
+            'dataType': subscriptionHash,
+        };
+        if (marketType === 'swap') {
+            request['reqType'] = 'sub';
+        }
+        const subscriptionArgs = {
+            'limit': limit,
+            'params': params,
+        };
+        const [symbol, timeframe, candles] = await this.watchMultiple(url, messageHashes, request, [subscriptionHash], subscriptionArgs);
+        if (this.newUpdates) {
+            limit = candles.getLimit(symbol, limit);
+        }
+        const filtered = this.filterBySinceLimit(candles, since, limit, 0, true);
+        return this.createOHLCVObject(symbol, timeframe, filtered);
+    }
+    getOrderBookLimitByMarketType(marketType, limit = undefined) {
+        if (limit === undefined) {
+            limit = 100;
+        }
+        else {
+            if (marketType === 'swap' || marketType === 'future') {
+                limit = this.findNearestCeiling([5, 10, 20, 50, 100], limit);
+            }
+            else if (marketType === 'spot') {
+                limit = this.findNearestCeiling([20, 100], limit);
+            }
+        }
+        return limit;
+    }
+    getMessageHash(unifiedChannel, symbol = undefined, extra = undefined) {
+        let hash = unifiedChannel;
+        if (symbol !== undefined) {
+            hash += '::' + symbol;
+        }
+        else {
+            hash += 's'; // tickers, orderbooks, ohlcvs ...
+        }
+        if (extra !== undefined) {
+            hash += '::' + extra;
+        }
+        return hash;
+    }
     async watchTrades(symbol, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -355,35 +568,34 @@ export default class bingx extends bingxRest {
         await this.loadMarkets();
         const market = this.market(symbol);
         const [marketType, query] = this.handleMarketTypeAndParams('watchOrderBook', market, params);
-        if (limit === undefined) {
-            limit = 100;
-        }
-        else {
-            if (marketType === 'swap') {
-                if ((limit !== 5) && (limit !== 10) && (limit !== 20) && (limit !== 50) && (limit !== 100)) {
-                    throw new BadRequest(this.id + ' watchOrderBook() (swap) only supports limit 5, 10, 20, 50, and 100');
-                }
-            }
-            else if (marketType === 'spot') {
-                if ((limit !== 20) && (limit !== 100)) {
-                    throw new BadRequest(this.id + ' watchOrderBook() (spot) only supports limit 20, and 100');
-                }
-            }
-        }
+        limit = this.getOrderBookLimitByMarketType(marketType, limit);
+        let channelName = 'depth' + limit.toString();
         const url = this.safeValue(this.urls['api']['ws'], marketType);
         if (url === undefined) {
             throw new BadRequest(this.id + ' watchOrderBook is not supported for ' + marketType + ' markets.');
         }
-        const messageHash = market['id'] + '@depth' + limit.toString();
+        let interval = undefined;
+        if (marketType !== 'spot') {
+            [interval, params] = this.handleOptionAndParams(params, 'watchOrderBook', 'interval', 500);
+            this.checkRequiredArgument('watchOrderBook', interval, 'interval', [100, 200, 500, 1000]);
+            channelName = channelName + '@' + interval.toString() + 'ms';
+        }
+        const subscriptionHash = market['id'] + '@' + channelName;
+        const messageHash = this.getMessageHash('orderbook', market['symbol']);
         const uuid = this.uuid();
         const request = {
             'id': uuid,
-            'dataType': messageHash,
+            'dataType': subscriptionHash,
         };
         if (marketType === 'swap') {
             request['reqType'] = 'sub';
         }
-        const orderbook = await this.watch(url, messageHash, this.deepExtend(request, query), messageHash);
+        const subscriptionArgs = {
+            'limit': limit,
+            'interval': interval,
+            'params': params,
+        };
+        const orderbook = await this.watch(url, messageHash, this.deepExtend(request, query), subscriptionHash, subscriptionArgs);
         return orderbook.limit();
     }
     handleDelta(bookside, delta) {
@@ -418,7 +630,7 @@ export default class bingx extends bingxRest {
         //
         //    {
         //        "code": 0,
-        //        "dataType": "BTC-USDT@depth20",
+        //        "dataType": "BTC-USDT@depth20@100ms", //or "all@depth20@100ms"
         //        "data": {
         //          "bids": [
         //            [ '28852.9', "34.2621" ],
@@ -427,25 +639,39 @@ export default class bingx extends bingxRest {
         //          "asks": [
         //            [ '28864.9', "23.4079" ],
         //            ...
-        //          ]
+        //          ],
+        //          "symbol": "BTC-USDT", // this key exists only in "all" subscription
         //        }
         //    }
         //
-        const data = this.safeValue(message, 'data', []);
-        const messageHash = this.safeString(message, 'dataType');
-        const marketId = messageHash.split('@')[0];
+        const data = this.safeDict(message, 'data', {});
+        const dataType = this.safeString(message, 'dataType');
+        const parts = dataType.split('@');
+        const firstPart = parts[0];
+        const isAllEndpoint = (firstPart === 'all');
+        const marketId = this.safeString(data, 'symbol', firstPart);
         const isSwap = client.url.indexOf('swap') >= 0;
         const marketType = isSwap ? 'swap' : 'spot';
         const market = this.safeMarket(marketId, undefined, undefined, marketType);
         const symbol = market['symbol'];
-        let orderbook = this.safeValue(this.orderbooks, symbol);
-        if (orderbook === undefined) {
-            orderbook = this.orderBook();
+        if (this.safeValue(this.orderbooks, symbol) === undefined) {
+            // const limit = [ 5, 10, 20, 50, 100 ]
+            const subscriptionHash = dataType;
+            const subscription = client.subscriptions[subscriptionHash];
+            const limit = this.safeInteger(subscription, 'limit');
+            this.orderbooks[symbol] = this.orderBook({}, limit);
         }
+        const orderbook = this.orderbooks[symbol];
         const snapshot = this.parseOrderBook(data, symbol, undefined, 'bids', 'asks', 0, 1);
         orderbook.reset(snapshot);
         this.orderbooks[symbol] = orderbook;
+        const messageHash = this.getMessageHash('orderbook', symbol);
         client.resolve(orderbook, messageHash);
+        // resolve for "all"
+        if (isAllEndpoint) {
+            const messageHashForAll = this.getMessageHash('orderbook');
+            client.resolve(orderbook, messageHashForAll);
+        }
     }
     parseWsOHLCV(ohlcv, market = undefined) {
         //
@@ -516,34 +742,48 @@ export default class bingx extends bingxRest {
         //        ]
         //    }
         //
-        const data = this.safeValue(message, 'data', []);
+        const data = this.safeList(message, 'data', []);
         let candles = undefined;
         if (Array.isArray(data)) {
             candles = data;
         }
         else {
-            candles = [this.safeValue(data, 'K', [])];
+            candles = [this.safeList(data, 'K', [])];
         }
-        const messageHash = this.safeString(message, 'dataType');
-        const timeframeId = messageHash.split('_')[1];
-        const marketId = messageHash.split('@')[0];
+        const dataType = this.safeString(message, 'dataType');
         const isSwap = client.url.indexOf('swap') >= 0;
+        const parts = dataType.split('@');
+        const firstPart = parts[0];
+        const isAllEndpoint = (firstPart === 'all');
+        const marketId = this.safeString(message, 's', firstPart);
         const marketType = isSwap ? 'swap' : 'spot';
         const market = this.safeMarket(marketId, undefined, undefined, marketType);
         const symbol = market['symbol'];
         this.ohlcvs[symbol] = this.safeValue(this.ohlcvs, symbol, {});
-        let stored = this.safeValue(this.ohlcvs[symbol], timeframeId);
-        if (stored === undefined) {
-            const limit = this.safeInteger(this.options, 'OHLCVLimit', 1000);
-            stored = new ArrayCacheByTimestamp(limit);
-            this.ohlcvs[symbol][timeframeId] = stored;
+        const rawTimeframe = dataType.split('_')[1];
+        const marketOptions = this.safeDict(this.options, marketType);
+        const timeframes = this.safeDict(marketOptions, 'timeframes', {});
+        const unifiedTimeframe = this.findTimeframe(rawTimeframe, timeframes);
+        if (this.safeValue(this.ohlcvs[symbol], rawTimeframe) === undefined) {
+            const subscriptionHash = dataType;
+            const subscription = client.subscriptions[subscriptionHash];
+            const limit = this.safeInteger(subscription, 'limit');
+            this.ohlcvs[symbol][unifiedTimeframe] = new ArrayCacheByTimestamp(limit);
         }
+        const stored = this.ohlcvs[symbol][unifiedTimeframe];
         for (let i = 0; i < candles.length; i++) {
             const candle = candles[i];
             const parsed = this.parseWsOHLCV(candle, market);
             stored.append(parsed);
         }
-        client.resolve(stored, messageHash);
+        const resolveData = [symbol, unifiedTimeframe, stored];
+        const messageHash = this.getMessageHash('ohlcv', symbol, unifiedTimeframe);
+        client.resolve(resolveData, messageHash);
+        // resolve for "all"
+        if (isAllEndpoint) {
+            const messageHashForAll = this.getMessageHash('ohlcv', undefined, unifiedTimeframe);
+            client.resolve(resolveData, messageHashForAll);
+        }
     }
     async watchOHLCV(symbol, timeframe = '1m', since = undefined, limit = undefined, params = {}) {
         /**
@@ -568,17 +808,23 @@ export default class bingx extends bingxRest {
         }
         const options = this.safeValue(this.options, marketType, {});
         const timeframes = this.safeValue(options, 'timeframes', {});
-        const interval = this.safeString(timeframes, timeframe, timeframe);
-        const messageHash = market['id'] + '@kline_' + interval;
+        const rawTimeframe = this.safeString(timeframes, timeframe, timeframe);
+        const messageHash = this.getMessageHash('ohlcv', market['symbol'], timeframe);
+        const subscriptionHash = market['id'] + '@kline_' + rawTimeframe;
         const uuid = this.uuid();
         const request = {
             'id': uuid,
-            'dataType': messageHash,
+            'dataType': subscriptionHash,
         };
         if (marketType === 'swap') {
             request['reqType'] = 'sub';
         }
-        const ohlcv = await this.watch(url, messageHash, this.extend(request, query), messageHash);
+        const subscriptionArgs = {
+            'limit': limit,
+            'params': params,
+        };
+        const result = await this.watch(url, messageHash, this.extend(request, query), subscriptionHash, subscriptionArgs);
+        const ohlcv = result[2];
         if (this.newUpdates) {
             limit = ohlcv.getLimit(symbol, limit);
         }

package/js/src/pro/bitget.js

@@ -992,7 +992,7 @@ export default class bitget extends bitgetRest {
         [type, params] = this.handleMarketTypeAndParams('watchOrders', market, params);
         let subType = undefined;
         [subType, params] = this.handleSubTypeAndParams('watchOrders', market, params, 'linear');
-        if ((type === 'spot') && (symbol === undefined)) {
+        if ((type === 'spot' || type === 'margin') && (symbol === undefined)) {
             throw new ArgumentsRequired(this.id + ' watchOrders requires a symbol argument for ' + type + ' markets.');
         }
         if ((productType === undefined) && (type !== 'spot') && (symbol === undefined)) {
@@ -1015,12 +1015,13 @@ export default class bitget extends bitgetRest {
         if (isTrigger) {
             subscriptionHash = subscriptionHash + ':stop'; // we don't want to re-use the same subscription hash for stop orders
         }
-        const instId = (type === 'spot') ? marketId : 'default'; // different from other streams here the 'rest' id is required for spot markets, contract markets require default here
+        const instId = (type === 'spot' || type === 'margin') ? marketId : 'default'; // different from other streams here the 'rest' id is required for spot markets, contract markets require default here
         let channel = isTrigger ? 'orders-algo' : 'orders';
         let marginMode = undefined;
         [marginMode, params] = this.handleMarginModeAndParams('watchOrders', params);
         if (marginMode !== undefined) {
             instType = 'MARGIN';
+            messageHash = messageHash + ':' + marginMode;
             if (marginMode === 'isolated') {
                 channel = 'orders-isolated';
             }
@@ -1075,9 +1076,10 @@ export default class bitget extends bitgetRest {
         //         "ts": 1701923982497
         //     }
         //
-        const arg = this.safeValue(message, 'arg', {});
+        const arg = this.safeDict(message, 'arg', {});
         const channel = this.safeString(arg, 'channel');
         const instType = this.safeString(arg, 'instType');
+        const argInstId = this.safeString(arg, 'instId');
         let marketType = undefined;
         if (instType === 'SPOT') {
             marketType = 'spot';
@@ -1103,7 +1105,7 @@ export default class bitget extends bitgetRest {
         const marketSymbols = {};
         for (let i = 0; i < data.length; i++) {
             const order = data[i];
-            const marketId = this.safeString(order, 'instId');
+            const marketId = this.safeString(order, 'instId', argInstId);
             const market = this.safeMarket(marketId, undefined, undefined, marketType);
             const parsed = this.parseWsOrder(order, market);
             stored.append(parsed);
@@ -1113,7 +1115,13 @@ export default class bitget extends bitgetRest {
         const keys = Object.keys(marketSymbols);
         for (let i = 0; i < keys.length; i++) {
             const symbol = keys[i];
-            const innerMessageHash = messageHash + ':' + symbol;
+            let innerMessageHash = messageHash + ':' + symbol;
+            if (channel === 'orders-crossed') {
+                innerMessageHash = innerMessageHash + ':cross';
+            }
+            else if (channel === 'orders-isolated') {
+                innerMessageHash = innerMessageHash + ':isolated';
+            }
             client.resolve(stored, innerMessageHash);
         }
         client.resolve(stored, messageHash);
@@ -1314,7 +1322,7 @@ export default class bitget extends bitgetRest {
             totalAmount = this.safeString(order, 'size');
             cost = this.safeString(order, 'fillNotionalUsd');
         }
-        remaining = this.omitZero(Precise.stringSub(totalAmount, totalFilled));
+        remaining = Precise.stringSub(totalAmount, totalFilled);
         return this.safeOrder({
             'info': order,
             'symbol': symbol,

package/js/src/pro/bitrue.js

@@ -349,13 +349,12 @@ export default class bitrue extends bitrueRest {
         const symbol = market['symbol'];
         const timestamp = this.safeInteger(message, 'ts');
         const tick = this.safeValue(message, 'tick', {});
-        let orderbook = this.safeValue(this.orderbooks, symbol);
-        if (orderbook === undefined) {
-            orderbook = this.orderBook();
+        if (!(symbol in this.orderbooks)) {
+            this.orderbooks[symbol] = this.orderBook();
         }
+        const orderbook = this.orderbooks[symbol];
         const snapshot = this.parseOrderBook(tick, symbol, timestamp, 'buys', 'asks');
         orderbook.reset(snapshot);
-        this.orderbooks[symbol] = orderbook;
         const messageHash = 'orderbook:' + symbol;
         client.resolve(orderbook, messageHash);
     }

package/js/src/pro/currencycom.js

@@ -458,17 +458,18 @@ export default class currencycom extends currencycomRest {
         const destination = 'depthMarketData.subscribe';
         const messageHash = destination + ':' + symbol;
         const timestamp = this.safeInteger(data, 'ts');
-        let orderbook = this.safeValue(this.orderbooks, symbol);
-        if (orderbook === undefined) {
-            orderbook = this.orderBook();
+        // let orderbook = this.safeValue (this.orderbooks, symbol);
+        if (!(symbol in this.orderbooks)) {
+            this.orderbooks[symbol] = this.orderBook();
         }
+        const orderbook = this.orderbooks[symbol];
         orderbook.reset({
             'symbol': symbol,
             'timestamp': timestamp,
             'datetime': this.iso8601(timestamp),
         });
-        const bids = this.safeValue(data, 'bid', {});
-        const asks = this.safeValue(data, 'ofr', {});
+        const bids = this.safeDict(data, 'bid', {});
+        const asks = this.safeDict(data, 'ofr', {});
         this.handleDeltas(orderbook['bids'], bids);
         this.handleDeltas(orderbook['asks'], asks);
         this.orderbooks[symbol] = orderbook;

package/js/src/pro/exmo.js

@@ -515,19 +515,18 @@ export default class exmo extends exmoRest {
         const orderBook = this.safeValue(message, 'data', {});
         const messageHash = 'orderbook:' + symbol;
         const timestamp = this.safeInteger(message, 'ts');
-        let orderbook = this.safeValue(this.orderbooks, symbol);
-        if (orderbook === undefined) {
-            orderbook = this.orderBook({});
-            this.orderbooks[symbol] = orderbook;
+        if (!(symbol in this.orderbooks)) {
+            this.orderbooks[symbol] = this.orderBook({});
         }
+        const orderbook = this.orderbooks[symbol];
         const event = this.safeString(message, 'event');
         if (event === 'snapshot') {
             const snapshot = this.parseOrderBook(orderBook, symbol, timestamp, 'bid', 'ask');
             orderbook.reset(snapshot);
         }
         else {
-            const asks = this.safeValue(orderBook, 'ask', []);
-            const bids = this.safeValue(orderBook, 'bid', []);
+            const asks = this.safeList(orderBook, 'ask', []);
+            const bids = this.safeList(orderBook, 'bid', []);
             this.handleDeltas(orderbook['asks'], asks);
             this.handleDeltas(orderbook['bids'], bids);
             orderbook['timestamp'] = timestamp;

package/js/src/pro/gemini.js

@@ -387,10 +387,11 @@ export default class gemini extends geminiRest {
         const market = this.safeMarket(marketId);
         const symbol = market['symbol'];
         const messageHash = 'orderbook:' + symbol;
-        let orderbook = this.safeValue(this.orderbooks, symbol);
-        if (orderbook === undefined) {
-            orderbook = this.orderBook();
+        // let orderbook = this.safeValue (this.orderbooks, symbol);
+        if (!(symbol in this.orderbooks)) {
+            this.orderbooks[symbol] = this.orderBook();
         }
+        const orderbook = this.orderbooks[symbol];
         for (let i = 0; i < changes.length; i++) {
             const delta = changes[i];
             const price = this.safeNumber(delta, 1);