ccxt 4.1.8 → 4.1.9

package/dist/ccxt.browser.js

@@ -9817,6 +9817,9 @@ class Exchange {
     async fetchOpenInterest(symbol, params = {}) {
         throw new _errors_js__WEBPACK_IMPORTED_MODULE_3__.NotSupported(this.id + ' fetchOpenInterest() is not supported yet');
     }
+    async fetchFundingRateHistory(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        throw new _errors_js__WEBPACK_IMPORTED_MODULE_3__.NotSupported(this.id + ' fetchFundingRateHistory() is not supported yet');
+    }
     parseLastPrice(price, market = undefined) {
         throw new _errors_js__WEBPACK_IMPORTED_MODULE_3__.NotSupported(this.id + ' parseLastPrice() is not supported yet');
     }
@@ -10707,7 +10710,9 @@ class Exchange {
                 }
             }
         }
-        return this.removeRepeatedElementsFromArray(result);
+        const uniqueResults = this.removeRepeatedElementsFromArray(result);
+        const key = (method === 'fetchOHLCV') ? 0 : 'timestamp';
+        return this.filterBySinceLimit(uniqueResults, since, limit, key);
     }
     async safeDeterministicCall(method, symbol = undefined, since = undefined, limit = undefined, timeframe = undefined, params = {}) {
         let maxRetries = undefined;
@@ -10762,7 +10767,9 @@ class Exchange {
         for (let i = 0; i < results.length; i++) {
             result = this.arrayConcat(result, results[i]);
         }
-        return this.removeRepeatedElementsFromArray(result);
+        const uniqueResults = this.removeRepeatedElementsFromArray(result);
+        const key = (method === 'fetchOHLCV') ? 0 : 'timestamp';
+        return this.filterBySinceLimit(uniqueResults, since, limit, key);
     }
     async fetchPaginatedCallCursor(method, symbol = undefined, since = undefined, limit = undefined, params = {}, cursorReceived = undefined, cursorSent = undefined, cursorIncrement = undefined, maxEntriesPerRequest = undefined) {
         let maxCalls = undefined;
@@ -10806,6 +10813,55 @@ class Exchange {
             }
             i += 1;
         }
+        const sorted = this.sortCursorPaginatedResult(result);
+        const key = (method === 'fetchOHLCV') ? 0 : 'timestamp';
+        return this.filterBySinceLimit(sorted, since, limit, key);
+    }
+    async fetchPaginatedCallIncremental(method, symbol = undefined, since = undefined, limit = undefined, params = {}, pageKey = undefined, maxEntriesPerRequest = undefined) {
+        let maxCalls = undefined;
+        [maxCalls, params] = this.handleOptionAndParams(params, method, 'paginationCalls', 10);
+        let maxRetries = undefined;
+        [maxRetries, params] = this.handleOptionAndParams(params, method, 'maxRetries', 3);
+        [maxEntriesPerRequest, params] = this.handleMaxEntriesPerRequestAndParams(method, maxEntriesPerRequest, params);
+        let i = 0;
+        let errors = 0;
+        let result = [];
+        while (i < maxCalls) {
+            try {
+                params[pageKey] = i + 1;
+                const response = await this[method](symbol, since, maxEntriesPerRequest, params);
+                errors = 0;
+                const responseLength = response.length;
+                if (this.verbose) {
+                    this.log('Incremental pagination call', i + 1, 'method', method, 'response length', responseLength);
+                }
+                if (responseLength === 0) {
+                    break;
+                }
+                result = this.arrayConcat(result, response);
+            }
+            catch (e) {
+                errors += 1;
+                if (errors > maxRetries) {
+                    throw e;
+                }
+            }
+            i += 1;
+        }
+        const sorted = this.sortCursorPaginatedResult(result);
+        const key = (method === 'fetchOHLCV') ? 0 : 'timestamp';
+        return this.filterBySinceLimit(sorted, since, limit, key);
+    }
+    sortCursorPaginatedResult(result) {
+        const first = this.safeValue(result, 0);
+        if (first !== undefined) {
+            if ('timestamp' in first) {
+                return this.sortBy(result, 'timestamp');
+            }
+            if ('id' in first) {
+                return this.sortBy(result, 'id');
+            }
+        }
         return result;
     }
     removeRepeatedElementsFromArray(input) {
@@ -25320,6 +25376,7 @@ class bingx extends _abstract_bingx_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"
                     'swap': 'https://open-api.{hostname}/openApi',
                     'contract': 'https://open-api.{hostname}/openApi',
                     'wallets': 'https://open-api.{hostname}/openApi',
+                    'user': 'https://open-api.{hostname}/openApi',
                     'subAccount': 'https://open-api.{hostname}/openApi',
                     'account': 'https://open-api.{hostname}/openApi',
                 },
@@ -25488,6 +25545,15 @@ class bingx extends _abstract_bingx_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"
                         },
                     },
                 },
+                'user': {
+                    'auth': {
+                        'private': {
+                            'post': {
+                                'userDataStream': 1,
+                            },
+                        },
+                    },
+                },
                 'copyTrading': {
                     'v1': {
                         'private': {
@@ -25565,6 +25631,7 @@ class bingx extends _abstract_bingx_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"
             },
             'commonCurrencies': {},
             'options': {
+                'defaultType': 'spot',
                 'accountsByType': {
                     'spot': 'FUND',
                     'swap': 'PFUTURES',
@@ -26084,37 +26151,63 @@ class bingx extends _abstract_bingx_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"
         //        filledTime: '2023-07-04T20:56:01.000+0800'
         //    }
         //
-        let time = this.safeInteger2(trade, 'time', 'filledTm');
+        //
+        // ws
+        //
+        // spot
+        //
+        //    {
+        //        E: 1690214529432,
+        //        T: 1690214529386,
+        //        e: 'trade',
+        //        m: true,
+        //        p: '29110.19',
+        //        q: '0.1868',
+        //        s: 'BTC-USDT',
+        //        t: '57903921'
+        //    }
+        //
+        // swap
+        //
+        //    {
+        //        q: '0.0421',
+        //        p: '29023.5',
+        //        T: 1690221401344,
+        //        m: false,
+        //        s: 'BTC-USDT'
+        //    }
+        //
+        let time = this.safeIntegerN(trade, ['time', 'filledTm', 'T']);
         const datetimeId = this.safeString(trade, 'filledTm');
         if (datetimeId !== undefined) {
             time = this.parse8601(datetimeId);
         }
-        const isBuyerMaker = this.safeValue2(trade, 'buyerMaker', 'isBuyerMaker');
-        let takeOrMaker = undefined;
-        let side = undefined;
-        if (isBuyerMaker !== undefined) {
-            side = isBuyerMaker ? 'sell' : 'buy';
-            takeOrMaker = 'taker';
+        if (time === 0) {
+            time = undefined;
         }
+        const isBuyerMaker = this.safeValue2(trade, 'buyerMaker', 'isBuyerMaker');
+        const side = this.safeStringLower2(trade, 'side', 'S');
         const cost = this.safeString(trade, 'quoteQty');
         const type = (cost === undefined) ? 'spot' : 'swap';
-        const currencyId = this.safeString(trade, 'currency');
+        const currencyId = this.safeString2(trade, 'currency', 'N');
         const currencyCode = this.safeCurrencyCode(currencyId);
+        const m = this.safeValue(trade, 'm', false);
+        const marketId = this.safeString(trade, 's');
         return this.safeTrade({
-            'id': this.safeString2(trade, 'id', 'orderId'),
+            'id': this.safeStringN(trade, ['id', 't']),
             'info': trade,
             'timestamp': time,
             'datetime': this.iso8601(time),
-            'symbol': this.safeSymbol(undefined, market, '-', type),
-            'order': undefined,
-            'type': undefined,
-            'side': side,
-            'takerOrMaker': takeOrMaker,
-            'price': this.safeString(trade, 'price'),
-            'amount': this.safeString2(trade, 'qty', 'amount'),
+            'symbol': this.safeSymbol(marketId, market, '-', type),
+            'order': this.safeString2(trade, 'orderId', 'i'),
+            'type': this.safeStringLower(trade, 'o'),
+            'side': this.parseOrderSide(side),
+            'takerOrMaker': (isBuyerMaker || m) ? 'maker' : 'taker',
+            'price': this.safeString2(trade, 'price', 'p'),
+            'amount': this.safeStringN(trade, ['qty', 'amount', 'q']),
             'cost': cost,
             'fee': {
-                'cost': this.parseNumber(_base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise.stringAbs */ .O.stringAbs(this.safeString(trade, 'commission'))),
+                'cost': this.parseNumber(_base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise.stringAbs */ .O.stringAbs(this.safeString2(trade, 'commission', 'n'))),
                 'currency': currencyCode,
                 'rate': undefined,
             },
@@ -26834,15 +26927,20 @@ class bingx extends _abstract_bingx_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"
                 request['timeInForce'] = 'POC';
             }
             const createMarketBuyOrderRequiresPrice = this.safeValue(this.options, 'createMarketBuyOrderRequiresPrice', true);
-            if (createMarketBuyOrderRequiresPrice && isMarketOrder && (side === 'buy')) {
-                if (price === undefined) {
-                    throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.InvalidOrder(this.id + ' createOrder() requires price argument for market buy orders on spot markets to calculate the total amount to spend (amount * price), alternatively set the createMarketBuyOrderRequiresPrice option to false and pass in the cost to spend into the amount parameter');
+            if (isMarketOrder && (side === 'buy')) {
+                if (createMarketBuyOrderRequiresPrice) {
+                    if (price === undefined) {
+                        throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.InvalidOrder(this.id + ' createOrder() requires price argument for market buy orders on spot markets to calculate the total amount to spend (amount * price), alternatively set the createMarketBuyOrderRequiresPrice option to false and pass in the cost to spend into the amount parameter');
+                    }
+                    else {
+                        const amountString = this.numberToString(amount);
+                        const priceString = this.numberToString(price);
+                        const cost = this.parseNumber(_base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise.stringMul */ .O.stringMul(amountString, priceString));
+                        request['quoteOrderQty'] = this.priceToPrecision(symbol, cost);
+                    }
                 }
                 else {
-                    const amountString = this.numberToString(amount);
-                    const priceString = this.numberToString(price);
-                    const cost = this.parseNumber(_base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise.stringMul */ .O.stringMul(amountString, priceString));
-                    request['quoteOrderQty'] = this.priceToPrecision(symbol, cost);
+                    request['quoteOrderQty'] = this.priceToPrecision(symbol, amount);
                 }
             }
             else {
@@ -26958,6 +27056,15 @@ class bingx extends _abstract_bingx_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"
         const order = this.safeValue(data, 'order', data);
         return this.parseOrder(order, market);
     }
+    parseOrderSide(side) {
+        const sides = {
+            'BUY': 'buy',
+            'SELL': 'sell',
+            'SHORT': 'sell',
+            'LONG': 'buy',
+        };
+        return this.safeString(sides, side, side);
+    }
     parseOrder(order, market = undefined) {
         //
         // spot
@@ -27055,39 +27162,49 @@ class bingx extends _abstract_bingx_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"
         //         "workingType": "MARK_PRICE"
         //     }
         //
-        const positionSide = this.safeString(order, 'positionSide');
+        const positionSide = this.safeString2(order, 'positionSide', 'ps');
         const marketType = (positionSide === undefined) ? 'spot' : 'swap';
-        const marketId = this.safeString(order, 'symbol');
+        const marketId = this.safeString2(order, 'symbol', 's');
         const symbol = this.safeSymbol(marketId, market, '-', marketType);
-        const timestamp = this.safeInteger2(order, 'time', 'transactTime');
+        const orderId = this.safeString2(order, 'orderId', 'i');
+        const side = this.safeStringLower2(order, 'side', 'S');
+        const type = this.safeStringLower2(order, 'type', 'o');
+        const timestamp = this.safeIntegerN(order, ['time', 'transactTime', 'E']);
+        const lastTradeTimestamp = this.safeInteger2(order, 'updateTime', 'T');
+        const price = this.safeString2(order, 'price', 'p');
+        const average = this.safeString2(order, 'avgPrice', 'ap');
+        const amount = this.safeString2(order, 'origQty', 'q');
+        const filled = this.safeString2(order, 'executedQty', 'z');
+        const statusId = this.safeString2(order, 'status', 'X');
         const fee = {
-            'currency': this.safeString(order, 'feeAsset'),
-            'rate': this.safeString2(order, 'fee', 'commission'),
+            'currency': this.safeString2(order, 'feeAsset', 'N'),
+            'rate': this.safeStringN(order, ['fee', 'commission', 'n']),
         };
+        const clientOrderId = this.safeString2(order, 'clientOrderId', 'c');
         return this.safeOrder({
             'info': order,
-            'id': this.safeString(order, 'orderId'),
-            'clientOrderId': this.safeString(order, 'clientOrderId'),
+            'id': orderId,
+            'clientOrderId': clientOrderId,
             'timestamp': timestamp,
             'datetime': this.iso8601(timestamp),
-            'lastTradeTimestamp': this.safeInteger(order, 'updateTime'),
+            'lastTradeTimestamp': lastTradeTimestamp,
             'lastUpdateTimestamp': this.safeInteger(order, 'updateTime'),
             'symbol': symbol,
-            'type': this.safeStringLower(order, 'type'),
+            'type': type,
             'timeInForce': undefined,
             'postOnly': undefined,
-            'side': this.safeStringLower(order, 'side'),
-            'price': this.safeString(order, 'price'),
+            'side': this.parseOrderSide(side),
+            'price': price,
             'stopPrice': this.safeNumber(order, 'stopPrice'),
             'triggerPrice': this.safeNumber(order, 'stopPrice'),
             'stopLossPrice': this.safeNumber(order, 'stopLoss'),
             'takeProfitPrice': this.safeNumber(order, 'takeProfit'),
-            'average': this.safeString(order, 'avgPrice'),
+            'average': average,
             'cost': undefined,
-            'amount': this.safeString(order, 'origQty'),
-            'filled': this.safeString(order, 'executedQty'),
+            'amount': amount,
+            'filled': filled,
             'remaining': undefined,
-            'status': this.parseOrderStatus(this.safeString(order, 'status')),
+            'status': this.parseOrderStatus(statusId),
             'fee': fee,
             'trades': undefined,
         }, market);
@@ -39721,8 +39838,26 @@ class bitget extends _abstract_bitget_js__WEBPACK_IMPORTED_MODULE_0__/* ["defaul
         //         "data": "888291686266343424"
         //     }
         //
+        //     {
+        //          "code":"00000",
+        //          "msg":"success",
+        //          "requestTime":1696784219602,
+        //          "data":{
+        //              "orderId":"1094957867615789056",
+        //              "clientOrderId":"64f1e4ce842041d296b4517df1b5c2d7"
+        //          }
+        //      }
+        //
+        const data = this.safeValue(response, 'data');
+        let id = undefined;
+        if (typeof data === 'string') {
+            id = data;
+        }
+        else if (data !== undefined) {
+            id = this.safeString(data, 'orderId');
+        }
         const result = {
-            'id': this.safeString(response, 'data'),
+            'id': id,
             'info': response,
             'txid': undefined,
             'timestamp': undefined,
@@ -42505,15 +42640,20 @@ class bitget extends _abstract_bitget_js__WEBPACK_IMPORTED_MODULE_0__/* ["defaul
          * @name bitget#fetchFundingRateHistory
          * @see https://bitgetlimited.github.io/apidoc/en/mix/#get-history-funding-rate
          * @description fetches historical funding rate prices
-         * @see https://bitgetlimited.github.io/apidoc/en/mix/#get-history-funding-rate
          * @param {string} symbol unified symbol of the market to fetch the funding rate history for
          * @param {int} [since] timestamp in ms of the earliest funding rate to fetch
          * @param {int} [limit] the maximum amount of [funding rate structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#funding-rate-history-structure} to fetch
          * @param {object} [params] extra parameters specific to the bitget api endpoint
+         * @param {boolean} [params.paginate] default false, when true will automatically paginate by calling this endpoint multiple times. See in the docs all the [availble parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
          * @returns {object[]} a list of [funding rate structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#funding-rate-history-structure}
          */
         this.checkRequiredSymbol('fetchFundingRateHistory', symbol);
         await this.loadMarkets();
+        let paginate = false;
+        [paginate, params] = this.handleOptionAndParams(params, 'fetchFundingRateHistory', 'paginate');
+        if (paginate) {
+            return await this.fetchPaginatedCallIncremental('fetchFundingRateHistory', symbol, since, limit, params, 'pageNo', 50);
+        }
         const market = this.market(symbol);
         const request = {
             'symbol': market['id'],
@@ -42524,6 +42664,7 @@ class bitget extends _abstract_bitget_js__WEBPACK_IMPORTED_MODULE_0__/* ["defaul
         if (limit !== undefined) {
             request['pageSize'] = limit;
         }
+        request['nextPage'] = true;
         const response = await this.publicMixGetMarketHistoryFundRate(this.extend(request, params));
         //
         //     {
@@ -117938,6 +118079,13 @@ class gate extends _abstract_gate_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"]
         //        "memo": null
         //    }
         //
+        //     {
+        //         "currency":"usdt",
+        //         "address":"0x01b0A9b7b4CdE774AF0f3E47CB4f1c2CCdBa0806",
+        //         "amount":"1880",
+        //         "chain":"eth"
+        //     }
+        //
         const id = this.safeString(transaction, 'id');
         let type = undefined;
         let amountString = this.safeString(transaction, 'amount');
@@ -117955,6 +118103,7 @@ class gate extends _abstract_gate_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"]
         if (type === 'withdrawal') {
             amountString = _base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise.stringSub */ .O.stringSub(amountString, feeCostString);
         }
+        const networkId = this.safeStringUpper(transaction, 'chain');
         const currencyId = this.safeString(transaction, 'currency');
         const code = this.safeCurrencyCode(currencyId);
         const txid = this.safeString(transaction, 'txid');
@@ -117969,7 +118118,7 @@ class gate extends _abstract_gate_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"]
             'txid': txid,
             'currency': code,
             'amount': this.parseNumber(amountString),
-            'network': undefined,
+            'network': this.networkIdToCode(networkId),
             'address': address,
             'addressTo': undefined,
             'addressFrom': undefined,
@@ -152788,12 +152937,12 @@ class kucoinfutures extends _abstract_kucoinfutures_js__WEBPACK_IMPORTED_MODULE_
     async fetchFundingRateHistory(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
-         * @name okx#fetchFundingRateHistory
+         * @name kucoinfutures#fetchFundingRateHistory
          * @description fetches historical funding rate prices
          * @param {string} symbol unified symbol of the market to fetch the funding rate history for
          * @param {int} [since] not used by kucuoinfutures
          * @param {int} [limit] the maximum amount of [funding rate structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#funding-rate-history-structure} to fetch
-         * @param {object} [params] extra parameters specific to the okx api endpoint
+         * @param {object} [params] extra parameters specific to the kucoinfutures api endpoint
          * @param {boolean} [params.paginate] default false, when true will automatically paginate by calling this endpoint multiple times. See in the docs all the [availble parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
          * @returns {object[]} a list of [funding rate structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#funding-rate-history-structure}
          */
@@ -197327,6 +197476,905 @@ class binanceusdm extends _binance_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"]
 }
 
 
+/***/ }),
+
+/***/ 6955:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "Z": () => (/* binding */ bingx)
+/* harmony export */ });
+/* harmony import */ var _bingx_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7960);
+/* harmony import */ var _base_errors_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6689);
+/* harmony import */ var _base_ws_Cache_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(3020);
+//  ---------------------------------------------------------------------------
+
+
+
+//  ---------------------------------------------------------------------------
+class bingx extends _bingx_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z {
+    describe() {
+        return this.deepExtend(super.describe(), {
+            'has': {
+                'ws': true,
+                'watchTrades': true,
+                'watchOrderBook': true,
+                'watchOHLCV': true,
+                'watchOrders': true,
+                'watchMyTrades': true,
+                'watchTicker': false,
+                'watchTickers': false,
+                'watchBalance': true,
+            },
+            'urls': {
+                'api': {
+                    'ws': {
+                        'spot': 'wss://open-api-ws.bingx.com/market',
+                        'swap': 'wss://open-api-swap.bingx.com/swap-market',
+                    },
+                },
+            },
+            'options': {
+                'ws': {
+                    'gunzip': true,
+                },
+                'swap': {
+                    'timeframes': {
+                        '1m': '1m',
+                        '3m': '3m',
+                        '5m': '5m',
+                        '15m': '15m',
+                        '30m': '30m',
+                        '1h': '1h',
+                        '2h': '2h',
+                        '4h': '4h',
+                        '6h': '6h',
+                        '12h': '12h',
+                        '1d': '1d',
+                        '3d': '3d',
+                        '1w': '1w',
+                        '1M': '1M',
+                    },
+                },
+                'spot': {
+                    'timeframes': {
+                        '1m': '1min',
+                        '5m': '5min',
+                        '15m': '15min',
+                        '30m': '30min',
+                        '1h': '60min',
+                        '1d': '1day',
+                    },
+                },
+            },
+            'streaming': {
+                'keepAlive': 1800000, // 30 minutes
+            },
+        });
+    }
+    async watchTrades(symbol, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name bingx#watchTrades
+         * @description watches information on multiple trades made in a market
+         * @see https://bingx-api.github.io/docs/#/spot/socket/market.html#Subscribe%20to%20tick-by-tick
+         * @see https://bingx-api.github.io/docs/#/swapV2/socket/market.html#Subscribe%20the%20Latest%20Trade%20Detail
+         * @param {string} symbol unified market symbol of the market orders were made in
+         * @param {int} [since] the earliest time in ms to fetch orders for
+         * @param {int} [limit] the maximum number of  orde structures to retrieve
+         * @param {object} [params] extra parameters specific to the bingx api endpoint
+         * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure
+         */
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const [marketType, query] = this.handleMarketTypeAndParams('watchTrades', market, params);
+        const url = this.safeValue(this.urls['api']['ws'], marketType);
+        if (url === undefined) {
+            throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.BadRequest(this.id + ' watchTrades is not supported for ' + marketType + ' markets.');
+        }
+        const messageHash = market['id'] + '@trade';
+        const uuid = this.uuid();
+        const request = {
+            'id': uuid,
+            'dataType': messageHash,
+        };
+        if (marketType === 'swap') {
+            request['reqType'] = 'sub';
+        }
+        const trades = await this.watch(url, messageHash, this.extend(request, query), messageHash);
+        if (this.newUpdates) {
+            limit = trades.getLimit(symbol, limit);
+        }
+        return this.filterBySinceLimit(trades, since, limit, 'timestamp', true);
+    }
+    handleTrades(client, message) {
+        //
+        // spot
+        // first snapshot
+        //
+        //    {
+        //      id: 'd83b78ce-98be-4dc2-b847-12fe471b5bc5',
+        //      code: 0,
+        //      msg: 'SUCCESS',
+        //      timestamp: 1690214699854
+        //    }
+        //
+        // subsequent updates
+        //
+        //     {
+        //         code: 0,
+        //         data: {
+        //           E: 1690214529432,
+        //           T: 1690214529386,
+        //           e: 'trade',
+        //           m: true,
+        //           p: '29110.19',
+        //           q: '0.1868',
+        //           s: 'BTC-USDT',
+        //           t: '57903921'
+        //         },
+        //         dataType: 'BTC-USDT@trade',
+        //         success: true
+        //     }
+        //
+        //
+        // swap
+        // first snapshot
+        //
+        //    {
+        //        id: '2aed93b1-6e1e-4038-aeba-f5eeaec2ca48',
+        //        code: 0,
+        //        msg: '',
+        //        dataType: '',
+        //        data: null
+        //    }
+        //
+        // subsequent updates
+        //
+        //
+        //    {
+        //        code: 0,
+        //        dataType: 'BTC-USDT@trade',
+        //        data: [
+        //            {
+        //                q: '0.0421',
+        //                p: '29023.5',
+        //                T: 1690221401344,
+        //                m: false,
+        //                s: 'BTC-USDT'
+        //            },
+        //            ...
+        //        ]
+        //    }
+        //
+        const data = this.safeValue(message, 'data', []);
+        const messageHash = this.safeString(message, 'dataType');
+        const marketId = messageHash.split('@')[0];
+        const marketType = client.url.indexOf('swap') >= 0 ? 'swap' : 'spot';
+        const market = this.safeMarket(marketId, undefined, undefined, marketType);
+        const symbol = market['symbol'];
+        let trades = undefined;
+        if (Array.isArray(data)) {
+            trades = this.parseTrades(data, market);
+        }
+        else {
+            trades = [this.parseTrade(data, market)];
+        }
+        let stored = this.safeValue(this.trades, symbol);
+        if (stored === undefined) {
+            const limit = this.safeInteger(this.options, 'tradesLimit', 1000);
+            stored = new _base_ws_Cache_js__WEBPACK_IMPORTED_MODULE_2__/* .ArrayCache */ .ZL(limit);
+            this.trades[symbol] = stored;
+        }
+        for (let j = 0; j < trades.length; j++) {
+            stored.append(trades[j]);
+        }
+        client.resolve(stored, messageHash);
+    }
+    async watchOrderBook(symbol, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name bingx#watchOrderBook
+         * @description watches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
+         * @see https://bingx-api.github.io/docs/#/spot/socket/market.html#Subscribe%20Market%20Depth%20Data
+         * @see https://bingx-api.github.io/docs/#/swapV2/socket/market.html#Subscribe%20Market%20Depth%20Data
+         * @param {string} symbol unified symbol of the market to fetch the order book for
+         * @param {int} [limit] the maximum amount of order book entries to return
+         * @param {object} [params] extra parameters specific to the bingx 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();
+        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 _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.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 _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.BadRequest(this.id + ' watchOrderBook() (spot) only supports limit 20, and 100');
+                }
+            }
+        }
+        const url = this.safeValue(this.urls['api']['ws'], marketType);
+        if (url === undefined) {
+            throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.BadRequest(this.id + ' watchOrderBook is not supported for ' + marketType + ' markets.');
+        }
+        const messageHash = market['id'] + '@depth' + limit.toString();
+        const uuid = this.uuid();
+        const request = {
+            'id': uuid,
+            'dataType': messageHash,
+        };
+        if (marketType === 'swap') {
+            request['reqType'] = 'sub';
+        }
+        const orderbook = await this.watch(url, messageHash, this.deepExtend(request, query), messageHash);
+        return orderbook.limit();
+    }
+    handleDelta(bookside, delta) {
+        const price = this.safeFloat(delta, 0);
+        const amount = this.safeFloat(delta, 1);
+        bookside.store(price, amount);
+    }
+    handleOrderBook(client, message) {
+        //
+        // spot
+        //
+        //
+        //    {
+        //        code: 0,
+        //        dataType: 'BTC-USDT@depth20',
+        //        data: {
+        //          bids: [
+        //            [ '28852.9', '34.2621' ],
+        //            ...
+        //          ],
+        //          asks: [
+        //            [ '28864.9', '23.4079' ],
+        //            ...
+        //          ]
+        //        },
+        //        dataType: 'BTC-USDT@depth20',
+        //        success: true
+        //    }
+        //
+        // swap
+        //
+        //
+        //    {
+        //        code: 0,
+        //        dataType: 'BTC-USDT@depth20',
+        //        data: {
+        //          bids: [
+        //            [ '28852.9', '34.2621' ],
+        //            ...
+        //          ],
+        //          asks: [
+        //            [ '28864.9', '23.4079' ],
+        //            ...
+        //          ]
+        //        }
+        //    }
+        //
+        const data = this.safeValue(message, 'data', []);
+        const messageHash = this.safeString(message, 'dataType');
+        const marketId = messageHash.split('@')[0];
+        const marketType = client.url.indexOf('swap') >= 0 ? '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();
+        }
+        const snapshot = this.parseOrderBook(data, symbol, undefined, 'bids', 'asks', 0, 1);
+        orderbook.reset(snapshot);
+        this.orderbooks[symbol] = orderbook;
+        client.resolve(orderbook, messageHash);
+    }
+    parseWsOHLCV(ohlcv, market = undefined) {
+        //
+        //    {
+        //        c: '28909.0',
+        //        o: '28915.4',
+        //        h: '28915.4',
+        //        l: '28896.1',
+        //        v: '27.6919',
+        //        T: 1690907580000
+        //    }
+        //
+        return [
+            this.safeInteger(ohlcv, 'T'),
+            this.safeNumber(ohlcv, 'o'),
+            this.safeNumber(ohlcv, 'h'),
+            this.safeNumber(ohlcv, 'l'),
+            this.safeNumber(ohlcv, 'c'),
+            this.safeNumber(ohlcv, 'v'),
+        ];
+    }
+    handleOHLCV(client, message) {
+        //
+        // spot
+        //
+        //   {
+        //       code: 0,
+        //       data: {
+        //         E: 1696687498608,
+        //         K: {
+        //           T: 1696687499999,
+        //           c: '27917.829',
+        //           h: '27918.427',
+        //           i: '1min',
+        //           l: '27917.7',
+        //           n: 262,
+        //           o: '27917.91',
+        //           q: '25715.359197',
+        //           s: 'BTC-USDT',
+        //           t: 1696687440000,
+        //           v: '0.921100'
+        //         },
+        //         e: 'kline',
+        //         s: 'BTC-USDT'
+        //       },
+        //       dataType: 'BTC-USDT@kline_1min',
+        //       success: true
+        //   }
+        //
+        // swap
+        //    {
+        //        code: 0,
+        //        dataType: 'BTC-USDT@kline_1m',
+        //        s: 'BTC-USDT',
+        //        data: [
+        //            {
+        //            c: '28909.0',
+        //            o: '28915.4',
+        //            h: '28915.4',
+        //            l: '28896.1',
+        //            v: '27.6919',
+        //            T: 1690907580000
+        //            }
+        //        ]
+        //    }
+        //
+        const data = this.safeValue(message, 'data', []);
+        let candles = undefined;
+        if (Array.isArray(data)) {
+            candles = data;
+        }
+        else {
+            candles = [this.safeValue(data, 'K', [])];
+        }
+        const messageHash = this.safeString(message, 'dataType');
+        const timeframeId = messageHash.split('_')[1];
+        const marketId = messageHash.split('@')[0];
+        const marketType = client.url.indexOf('swap') >= 0 ? '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 _base_ws_Cache_js__WEBPACK_IMPORTED_MODULE_2__/* .ArrayCacheByTimestamp */ .Py(limit);
+            this.ohlcvs[symbol][timeframeId] = stored;
+        }
+        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);
+    }
+    async watchOHLCV(symbol, timeframe = '1m', since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name bingx#watchOHLCV
+         * @description watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+         * @see https://bingx-api.github.io/docs/#/spot/socket/market.html#K%E7%BA%BF%20Streams
+         * @see https://bingx-api.github.io/docs/#/swapV2/socket/market.html#Subscribe%20K-Line%20Data
+         * @param {string} symbol unified symbol of the market to fetch OHLCV data for
+         * @param {string} timeframe the length of time each candle represents
+         * @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 bingx api endpoint
+         * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
+         */
+        const market = this.market(symbol);
+        const [marketType, query] = this.handleMarketTypeAndParams('watchOHLCV', market, params);
+        const url = this.safeValue(this.urls['api']['ws'], marketType);
+        if (url === undefined) {
+            throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.BadRequest(this.id + ' watchOHLCV is not supported for ' + marketType + ' markets.');
+        }
+        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 uuid = this.uuid();
+        const request = {
+            'id': uuid,
+            'dataType': messageHash,
+        };
+        if (marketType === 'swap') {
+            request['reqType'] = 'sub';
+        }
+        const ohlcv = await this.watch(url, messageHash, this.extend(request, query), messageHash);
+        if (this.newUpdates) {
+            limit = ohlcv.getLimit(symbol, limit);
+        }
+        return this.filterBySinceLimit(ohlcv, since, limit, 0, true);
+    }
+    async watchOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name bingx#watchOrders
+         * @see https://bingx-api.github.io/docs/#/spot/socket/account.html#Subscription%20order%20update%20data
+         * @see https://bingx-api.github.io/docs/#/swapV2/socket/account.html#Account%20balance%20and%20position%20update%20push
+         * @description watches information on multiple orders made by the user
+         * @param {string} symbol unified market symbol of the market orders were made in
+         * @param {int} [since] the earliest time in ms to fetch orders for
+         * @param {int} [limit] the maximum number of  orde structures to retrieve
+         * @param {object} [params] extra parameters specific to the bingx api endpoint
+         * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        await this.loadMarkets();
+        await this.authenticate();
+        let type = undefined;
+        let market = undefined;
+        if (symbol !== undefined) {
+            market = this.market(symbol);
+            symbol = market['symbol'];
+        }
+        [type, params] = this.handleMarketTypeAndParams('watchOrders', market, params);
+        const isSpot = (type === 'spot');
+        const spotHash = 'spot:private';
+        const swapHash = 'swap:private';
+        const subscriptionHash = isSpot ? spotHash : swapHash;
+        const spotMessageHash = 'spot:order';
+        const swapMessageHash = 'swap:order';
+        let messageHash = isSpot ? spotMessageHash : swapMessageHash;
+        if (market !== undefined) {
+            messageHash += ':' + symbol;
+        }
+        const url = this.urls['api']['ws'][type] + '?listenKey=' + this.options['listenKey'];
+        let request = undefined;
+        const uuid = this.uuid();
+        if (isSpot) {
+            request = {
+                'id': uuid,
+                'dataType': 'spot.executionReport',
+            };
+        }
+        const orders = await this.watch(url, messageHash, request, subscriptionHash);
+        if (this.newUpdates) {
+            limit = orders.getLimit(symbol, limit);
+        }
+        return this.filterBySymbolSinceLimit(orders, symbol, since, limit, true);
+    }
+    async watchMyTrades(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name bingx#watchMyTrades
+         * @see https://bingx-api.github.io/docs/#/spot/socket/account.html#Subscription%20order%20update%20data
+         * @see https://bingx-api.github.io/docs/#/swapV2/socket/account.html#Account%20balance%20and%20position%20update%20push
+         * @description watches information on multiple trades made by the user
+         * @param {string} symbol unified market symbol of the market trades were made in
+         * @param {int} [since] the earliest time in ms to trades orders for
+         * @param {int} [limit] the maximum number of trades structures to retrieve
+         * @param {object} [params] extra parameters specific to the bingx api endpoint
+         * @returns {object[]} a list of [trade structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#trade-structure
+         */
+        await this.loadMarkets();
+        await this.authenticate();
+        let type = undefined;
+        let market = undefined;
+        if (symbol !== undefined) {
+            market = this.market(symbol);
+            symbol = market['symbol'];
+        }
+        [type, params] = this.handleMarketTypeAndParams('watchOrders', market, params);
+        const isSpot = (type === 'spot');
+        const spotSubHash = 'spot:private';
+        const swapSubHash = 'swap:private';
+        const subscriptionHash = isSpot ? spotSubHash : swapSubHash;
+        const spotMessageHash = 'spot:mytrades';
+        const swapMessageHash = 'swap:mytrades';
+        let messageHash = isSpot ? spotMessageHash : swapMessageHash;
+        if (market !== undefined) {
+            messageHash += ':' + symbol;
+        }
+        const url = this.urls['api']['ws'][type] + '?listenKey=' + this.options['listenKey'];
+        let request = undefined;
+        const uuid = this.uuid();
+        if (isSpot) {
+            request = {
+                'id': uuid,
+                'dataType': 'spot.executionReport',
+            };
+        }
+        const trades = await this.watch(url, messageHash, request, subscriptionHash);
+        if (this.newUpdates) {
+            limit = trades.getLimit(symbol, limit);
+        }
+        return this.filterBySymbolSinceLimit(trades, symbol, since, limit, true);
+    }
+    async watchBalance(params = {}) {
+        /**
+         * @method
+         * @name bingx#watchBalance
+         * @see https://bingx-api.github.io/docs/#/spot/socket/account.html#Subscription%20order%20update%20data
+         * @see https://bingx-api.github.io/docs/#/swapV2/socket/account.html#Account%20balance%20and%20position%20update%20push
+         * @description query for balance and get the amount of funds available for trading or funds locked in orders
+         * @param {object} [params] extra parameters specific to the bingx api endpoint
+         * @returns {object} a [balance structure]{@link https://docs.ccxt.com/en/latest/manual.html?#balance-structure}
+         */
+        await this.loadMarkets();
+        await this.authenticate();
+        let type = undefined;
+        [type, params] = this.handleMarketTypeAndParams('watchBalance', undefined, params);
+        const isSpot = (type === 'spot');
+        const spotSubHash = 'spot:balance';
+        const swapSubHash = 'swap:private';
+        const spotMessageHash = 'spot:balance';
+        const swapMessageHash = 'swap:balance';
+        const messageHash = isSpot ? spotMessageHash : swapMessageHash;
+        const subscriptionHash = isSpot ? spotSubHash : swapSubHash;
+        const url = this.urls['api']['ws'][type] + '?listenKey=' + this.options['listenKey'];
+        let request = undefined;
+        const uuid = this.uuid();
+        if (type === 'spot') {
+            request = {
+                'id': uuid,
+                'dataType': 'ACCOUNT_UPDATE',
+            };
+        }
+        return await this.watch(url, messageHash, request, subscriptionHash);
+    }
+    handleErrorMessage(client, message) {
+        //
+        // { code: 100400, msg: '', timestamp: 1696245808833 }
+        //
+        // {
+        //     code: 100500,
+        //     id: '9cd37d32-da98-440b-bd04-37e7dbcf51ad',
+        //     msg: '',
+        //     timestamp: 1696245842307
+        // }
+        const code = this.safeString(message, 'code');
+        try {
+            if (code !== undefined) {
+                const feedback = this.id + ' ' + this.json(message);
+                this.throwExactlyMatchedException(this.exceptions['exact'], code, feedback);
+            }
+        }
+        catch (e) {
+            client.reject(e);
+        }
+        return true;
+    }
+    async authenticate(params = {}) {
+        const time = this.milliseconds();
+        const listenKey = this.safeString(this.options, 'listenKey');
+        if (listenKey === undefined) {
+            const response = await this.userAuthPrivatePostUserDataStream();
+            this.options['listenKey'] = this.safeString(response, 'listenKey');
+            this.options['lastAuthenticatedTime'] = time;
+            return;
+        }
+        const lastAuthenticatedTime = this.safeInteger(this.options, 'lastAuthenticatedTime', 0);
+        const listenKeyRefreshRate = this.safeInteger(this.options, 'listenKeyRefreshRate', 3600000); // 1 hour
+        if (time - lastAuthenticatedTime > listenKeyRefreshRate) {
+            const response = await this.userAuthPrivatePostUserDataStream({ 'listenKey': listenKey }); // extend the expiry
+            this.options['listenKey'] = this.safeString(response, 'listenKey');
+            this.options['lastAuthenticatedTime'] = time;
+        }
+    }
+    async pong(client, message) {
+        //
+        // spot
+        // {
+        //     ping: '5963ba3db76049b2870f9a686b2ebaac',
+        //     time: '2023-10-02T18:51:55.089+0800'
+        // }
+        // swap
+        // Ping
+        //
+        if (message === 'Ping') {
+            await client.send('Pong');
+        }
+        else {
+            const ping = this.safeString(message, 'ping');
+            const time = this.safeString(message, 'time');
+            await client.send({
+                'pong': ping,
+                'time': time,
+            });
+        }
+    }
+    handleOrder(client, message) {
+        //
+        //     {
+        //         "code": 0,
+        //         "dataType": "spot.executionReport",
+        //         "data": {
+        //            "e": "executionReport",
+        //            "E": 1694680212947,
+        //            "s": "LTC-USDT",
+        //            "S": "BUY",
+        //            "o": "LIMIT",
+        //            "q": 0.1,
+        //            "p": 50,
+        //            "x": "NEW",
+        //            "X": "PENDING",
+        //            "i": 1702238305204043800,
+        //            "l": 0,
+        //            "z": 0,
+        //            "L": 0,
+        //            "n": 0,
+        //            "N": "",
+        //            "T": 0,
+        //            "t": 0,
+        //            "O": 1694680212676,
+        //            "Z": 0,
+        //            "Y": 0,
+        //            "Q": 0,
+        //            "m": false
+        //         }
+        //      }
+        //
+        //      {
+        //         code: 0,
+        //         dataType: 'spot.executionReport',
+        //         data: {
+        //           e: 'executionReport',
+        //           E: 1694681809302,
+        //           s: 'LTC-USDT',
+        //           S: 'BUY',
+        //           o: 'MARKET',
+        //           q: 0,
+        //           p: 62.29,
+        //           x: 'TRADE',
+        //           X: 'FILLED',
+        //           i: '1702245001712369664',
+        //           l: 0.0802,
+        //           z: 0.0802,
+        //           L: 62.308,
+        //           n: -0.0000802,
+        //           N: 'LTC',
+        //           T: 1694681809256,
+        //           t: 38259147,
+        //           O: 1694681809248,
+        //           Z: 4.9971016,
+        //           Y: 4.9971016,
+        //           Q: 5,
+        //           m: false
+        //         }
+        //       }
+        // swap
+        //    {
+        //        "e": "ORDER_TRADE_UPDATE",
+        //        "E": 1696843635475,
+        //        "o": {
+        //           "s": "LTC-USDT",
+        //           "c": "",
+        //           "i": "1711312357852147712",
+        //           "S": "BUY",
+        //           "o": "MARKET",
+        //           "q": "0.10000000",
+        //           "p": "64.35010000",
+        //           "ap": "64.36000000",
+        //           "x": "TRADE",
+        //           "X": "FILLED",
+        //           "N": "USDT",
+        //           "n": "-0.00321800",
+        //           "T": 0,
+        //           "wt": "MARK_PRICE",
+        //           "ps": "LONG",
+        //           "rp": "0.00000000",
+        //           "z": "0.10000000"
+        //        }
+        //    }
+        //
+        const isSpot = ('dataType' in message);
+        const data = this.safeValue2(message, 'data', 'o', {});
+        if (this.orders === undefined) {
+            const limit = this.safeInteger(this.options, 'ordersLimit', 1000);
+            this.orders = new _base_ws_Cache_js__WEBPACK_IMPORTED_MODULE_2__/* .ArrayCacheBySymbolById */ .hl(limit);
+        }
+        const stored = this.orders;
+        const parsedOrder = this.parseOrder(data);
+        stored.append(parsedOrder);
+        const symbol = parsedOrder['symbol'];
+        const spotHash = 'spot:order';
+        const swapHash = 'swap:order';
+        const messageHash = (isSpot) ? spotHash : swapHash;
+        client.resolve(stored, messageHash);
+        client.resolve(stored, messageHash + ':' + symbol);
+    }
+    handleMyTrades(client, message) {
+        //
+        //
+        //      {
+        //         code: 0,
+        //         dataType: 'spot.executionReport',
+        //         data: {
+        //           e: 'executionReport',
+        //           E: 1694681809302,
+        //           s: 'LTC-USDT',
+        //           S: 'BUY',
+        //           o: 'MARKET',
+        //           q: 0,
+        //           p: 62.29,
+        //           x: 'TRADE',
+        //           X: 'FILLED',
+        //           i: '1702245001712369664',
+        //           l: 0.0802,
+        //           z: 0.0802,
+        //           L: 62.308,
+        //           n: -0.0000802,
+        //           N: 'LTC',
+        //           T: 1694681809256,
+        //           t: 38259147,
+        //           O: 1694681809248,
+        //           Z: 4.9971016,
+        //           Y: 4.9971016,
+        //           Q: 5,
+        //           m: false
+        //         }
+        //       }
+        //
+        //  swap
+        //    {
+        //        "e": "ORDER_TRADE_UPDATE",
+        //        "E": 1696843635475,
+        //        "o": {
+        //           "s": "LTC-USDT",
+        //           "c": "",
+        //           "i": "1711312357852147712",
+        //           "S": "BUY",
+        //           "o": "MARKET",
+        //           "q": "0.10000000",
+        //           "p": "64.35010000",
+        //           "ap": "64.36000000",
+        //           "x": "TRADE",
+        //           "X": "FILLED",
+        //           "N": "USDT",
+        //           "n": "-0.00321800",
+        //           "T": 0,
+        //           "wt": "MARK_PRICE",
+        //           "ps": "LONG",
+        //           "rp": "0.00000000",
+        //           "z": "0.10000000"
+        //        }
+        //    }
+        //
+        const isSpot = ('dataType' in message);
+        const result = this.safeValue2(message, 'data', 'o', {});
+        let cachedTrades = this.myTrades;
+        if (cachedTrades === undefined) {
+            const limit = this.safeInteger(this.options, 'tradesLimit', 1000);
+            cachedTrades = new _base_ws_Cache_js__WEBPACK_IMPORTED_MODULE_2__/* .ArrayCacheBySymbolById */ .hl(limit);
+            this.myTrades = cachedTrades;
+        }
+        const parsed = this.parseTrade(result);
+        const symbol = parsed['symbol'];
+        const spotHash = 'spot:mytrades';
+        const swapHash = 'swap:mytrades';
+        const messageHash = isSpot ? spotHash : swapHash;
+        cachedTrades.append(parsed);
+        client.resolve(cachedTrades, messageHash);
+        client.resolve(cachedTrades, messageHash + ':' + symbol);
+    }
+    handleBalance(client, message) {
+        // spot
+        //     {
+        //         "e":"ACCOUNT_UPDATE",
+        //         "E":1696242817000,
+        //         "T":1696242817142,
+        //         "a":{
+        //            "B":[
+        //               {
+        //                  "a":"USDT",
+        //                  "bc":"-1.00000000000000000000",
+        //                  "cw":"86.59497382000000050000",
+        //                  "wb":"86.59497382000000050000"
+        //               }
+        //            ],
+        //            "m":"ASSET_TRANSFER"
+        //         }
+        //     }
+        // swap
+        //     {
+        //         "e":"ACCOUNT_UPDATE",
+        //         "E":1696244249320,
+        //         "a":{
+        //            "m":"WITHDRAW",
+        //            "B":[
+        //               {
+        //                  "a":"USDT",
+        //                  "wb":"49.81083984",
+        //                  "cw":"49.81083984",
+        //                  "bc":"-1.00000000"
+        //               }
+        //            ],
+        //            "P":[
+        //            ]
+        //         }
+        //     }
+        //
+        const a = this.safeValue(message, 'a', {});
+        const data = this.safeValue(a, 'B', []);
+        const timestamp = this.safeInteger2(message, 'T', 'E');
+        const type = ('P' in a) ? 'swap' : 'spot';
+        if (!(type in this.balance)) {
+            this.balance[type] = {};
+        }
+        this.balance[type]['info'] = data;
+        this.balance[type]['timestamp'] = timestamp;
+        this.balance[type]['datetime'] = this.iso8601(timestamp);
+        for (let i = 0; i < data.length; i++) {
+            const balance = data[i];
+            const currencyId = this.safeString(balance, 'a');
+            const code = this.safeCurrencyCode(currencyId);
+            const account = (code in this.balance) ? this.balance[code] : this.account();
+            account['total'] = this.safeString(balance, 'wb');
+            this.balance[type][code] = account;
+        }
+        this.balance[type] = this.safeBalance(this.balance[type]);
+        client.resolve(this.balance[type], type + ':balance');
+    }
+    handleMessage(client, message) {
+        if (!this.handleErrorMessage(client, message)) {
+            return;
+        }
+        // public subscriptions
+        if ((message === 'Ping') || ('ping' in message)) {
+            this.spawn(this.pong, client, message);
+            return;
+        }
+        const dataType = this.safeString(message, 'dataType', '');
+        if (dataType.indexOf('@depth') >= 0) {
+            this.handleOrderBook(client, message);
+            return;
+        }
+        if (dataType.indexOf('@trade') >= 0) {
+            this.handleTrades(client, message);
+            return;
+        }
+        if (dataType.indexOf('@kline') >= 0) {
+            this.handleOHLCV(client, message);
+            return;
+        }
+        if (dataType.indexOf('executionReport') >= 0) {
+            const data = this.safeValue(message, 'data', {});
+            const type = this.safeString(data, 'x');
+            if (type === 'TRADE') {
+                this.handleMyTrades(client, message);
+            }
+            this.handleOrder(client, message);
+            return;
+        }
+        const e = this.safeString(message, 'e');
+        if (e === 'ACCOUNT_UPDATE') {
+            this.handleBalance(client, message);
+        }
+        if (e === 'ORDER_TRADE_UPDATE') {
+            this.handleOrder(client, message);
+            const data = this.safeValue(message, 'o', {});
+            const type = this.safeString(data, 'x');
+            const status = this.safeString(data, 'X');
+            if ((type === 'TRADE') && (status === 'FILLED')) {
+                this.handleMyTrades(client, message);
+            }
+        }
+    }
+}
+
+
 /***/ }),
 
 /***/ 453:
@@ -274917,39 +275965,39 @@ var __webpack_exports__ = {};
 (() => {
 __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   "AccountNotEnabled": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.AccountNotEnabled),
-/* harmony export */   "AccountSuspended": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.AccountSuspended),
-/* harmony export */   "AddressPending": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.AddressPending),
-/* harmony export */   "ArgumentsRequired": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.ArgumentsRequired),
-/* harmony export */   "AuthenticationError": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.AuthenticationError),
-/* harmony export */   "BadRequest": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.BadRequest),
-/* harmony export */   "BadResponse": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.BadResponse),
-/* harmony export */   "BadSymbol": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.BadSymbol),
-/* harmony export */   "BaseError": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.BaseError),
-/* harmony export */   "CancelPending": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.CancelPending),
-/* harmony export */   "DDoSProtection": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.DDoSProtection),
-/* harmony export */   "DuplicateOrderId": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.DuplicateOrderId),
+/* harmony export */   "AccountNotEnabled": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.AccountNotEnabled),
+/* harmony export */   "AccountSuspended": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.AccountSuspended),
+/* harmony export */   "AddressPending": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.AddressPending),
+/* harmony export */   "ArgumentsRequired": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.ArgumentsRequired),
+/* harmony export */   "AuthenticationError": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.AuthenticationError),
+/* harmony export */   "BadRequest": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.BadRequest),
+/* harmony export */   "BadResponse": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.BadResponse),
+/* harmony export */   "BadSymbol": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.BadSymbol),
+/* harmony export */   "BaseError": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.BaseError),
+/* harmony export */   "CancelPending": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.CancelPending),
+/* harmony export */   "DDoSProtection": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.DDoSProtection),
+/* harmony export */   "DuplicateOrderId": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.DuplicateOrderId),
 /* harmony export */   "Exchange": () => (/* reexport safe */ _src_base_Exchange_js__WEBPACK_IMPORTED_MODULE_0__.e),
-/* harmony export */   "ExchangeError": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.ExchangeError),
-/* harmony export */   "ExchangeNotAvailable": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.ExchangeNotAvailable),
-/* harmony export */   "InsufficientFunds": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.InsufficientFunds),
-/* harmony export */   "InvalidAddress": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.InvalidAddress),
-/* harmony export */   "InvalidNonce": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.InvalidNonce),
-/* harmony export */   "InvalidOrder": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.InvalidOrder),
-/* harmony export */   "MarginModeAlreadySet": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.MarginModeAlreadySet),
-/* harmony export */   "NetworkError": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.NetworkError),
-/* harmony export */   "NoChange": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.NoChange),
-/* harmony export */   "NotSupported": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.NotSupported),
-/* harmony export */   "NullResponse": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.NullResponse),
-/* harmony export */   "OnMaintenance": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.OnMaintenance),
-/* harmony export */   "OrderImmediatelyFillable": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.OrderImmediatelyFillable),
-/* harmony export */   "OrderNotCached": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.OrderNotCached),
-/* harmony export */   "OrderNotFillable": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.OrderNotFillable),
-/* harmony export */   "OrderNotFound": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.OrderNotFound),
-/* harmony export */   "PermissionDenied": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.PermissionDenied),
-/* harmony export */   "Precise": () => (/* reexport safe */ _src_base_Precise_js__WEBPACK_IMPORTED_MODULE_165__.O),
-/* harmony export */   "RateLimitExceeded": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.RateLimitExceeded),
-/* harmony export */   "RequestTimeout": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__.RequestTimeout),
+/* harmony export */   "ExchangeError": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.ExchangeError),
+/* harmony export */   "ExchangeNotAvailable": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.ExchangeNotAvailable),
+/* harmony export */   "InsufficientFunds": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.InsufficientFunds),
+/* harmony export */   "InvalidAddress": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.InvalidAddress),
+/* harmony export */   "InvalidNonce": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.InvalidNonce),
+/* harmony export */   "InvalidOrder": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.InvalidOrder),
+/* harmony export */   "MarginModeAlreadySet": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.MarginModeAlreadySet),
+/* harmony export */   "NetworkError": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.NetworkError),
+/* harmony export */   "NoChange": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.NoChange),
+/* harmony export */   "NotSupported": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.NotSupported),
+/* harmony export */   "NullResponse": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.NullResponse),
+/* harmony export */   "OnMaintenance": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.OnMaintenance),
+/* harmony export */   "OrderImmediatelyFillable": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.OrderImmediatelyFillable),
+/* harmony export */   "OrderNotCached": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.OrderNotCached),
+/* harmony export */   "OrderNotFillable": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.OrderNotFillable),
+/* harmony export */   "OrderNotFound": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.OrderNotFound),
+/* harmony export */   "PermissionDenied": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.PermissionDenied),
+/* harmony export */   "Precise": () => (/* reexport safe */ _src_base_Precise_js__WEBPACK_IMPORTED_MODULE_166__.O),
+/* harmony export */   "RateLimitExceeded": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.RateLimitExceeded),
+/* harmony export */   "RequestTimeout": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.RequestTimeout),
 /* harmony export */   "ace": () => (/* reexport safe */ _src_ace_js__WEBPACK_IMPORTED_MODULE_1__.Z),
 /* harmony export */   "alpaca": () => (/* reexport safe */ _src_alpaca_js__WEBPACK_IMPORTED_MODULE_2__.Z),
 /* harmony export */   "ascendex": () => (/* reexport safe */ _src_ascendex_js__WEBPACK_IMPORTED_MODULE_3__.Z),
@@ -275006,11 +276054,11 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "delta": () => (/* reexport safe */ _src_delta_js__WEBPACK_IMPORTED_MODULE_53__.Z),
 /* harmony export */   "deribit": () => (/* reexport safe */ _src_deribit_js__WEBPACK_IMPORTED_MODULE_54__.Z),
 /* harmony export */   "digifinex": () => (/* reexport safe */ _src_digifinex_js__WEBPACK_IMPORTED_MODULE_55__.Z),
-/* harmony export */   "errors": () => (/* reexport module object */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__),
+/* harmony export */   "errors": () => (/* reexport module object */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__),
 /* harmony export */   "exchanges": () => (/* binding */ exchanges),
 /* harmony export */   "exmo": () => (/* reexport safe */ _src_exmo_js__WEBPACK_IMPORTED_MODULE_56__.Z),
 /* harmony export */   "fmfwio": () => (/* reexport safe */ _src_fmfwio_js__WEBPACK_IMPORTED_MODULE_57__.Z),
-/* harmony export */   "functions": () => (/* reexport module object */ _src_base_functions_js__WEBPACK_IMPORTED_MODULE_166__),
+/* harmony export */   "functions": () => (/* reexport module object */ _src_base_functions_js__WEBPACK_IMPORTED_MODULE_167__),
 /* harmony export */   "gate": () => (/* reexport safe */ _src_gate_js__WEBPACK_IMPORTED_MODULE_58__.Z),
 /* harmony export */   "gateio": () => (/* reexport safe */ _src_gateio_js__WEBPACK_IMPORTED_MODULE_59__.Z),
 /* harmony export */   "gemini": () => (/* reexport safe */ _src_gemini_js__WEBPACK_IMPORTED_MODULE_60__.Z),
@@ -275063,9 +276111,9 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "zonda": () => (/* reexport safe */ _src_zonda_js__WEBPACK_IMPORTED_MODULE_105__.Z)
 /* harmony export */ });
 /* harmony import */ var _src_base_Exchange_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3043);
-/* harmony import */ var _src_base_Precise_js__WEBPACK_IMPORTED_MODULE_165__ = __webpack_require__(2194);
-/* harmony import */ var _src_base_functions_js__WEBPACK_IMPORTED_MODULE_166__ = __webpack_require__(7100);
-/* harmony import */ var _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__ = __webpack_require__(6689);
+/* harmony import */ var _src_base_Precise_js__WEBPACK_IMPORTED_MODULE_166__ = __webpack_require__(2194);
+/* harmony import */ var _src_base_functions_js__WEBPACK_IMPORTED_MODULE_167__ = __webpack_require__(7100);
+/* harmony import */ var _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__ = __webpack_require__(6689);
 /* harmony import */ var _src_ace_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(9869);
 /* harmony import */ var _src_alpaca_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(5660);
 /* harmony import */ var _src_ascendex_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(9612);
@@ -275178,58 +276226,59 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _src_pro_binancecoinm_js__WEBPACK_IMPORTED_MODULE_110__ = __webpack_require__(5078);
 /* harmony import */ var _src_pro_binanceus_js__WEBPACK_IMPORTED_MODULE_111__ = __webpack_require__(1326);
 /* harmony import */ var _src_pro_binanceusdm_js__WEBPACK_IMPORTED_MODULE_112__ = __webpack_require__(1230);
-/* harmony import */ var _src_pro_bitcoincom_js__WEBPACK_IMPORTED_MODULE_113__ = __webpack_require__(453);
-/* harmony import */ var _src_pro_bitfinex_js__WEBPACK_IMPORTED_MODULE_114__ = __webpack_require__(9772);
-/* harmony import */ var _src_pro_bitfinex2_js__WEBPACK_IMPORTED_MODULE_115__ = __webpack_require__(588);
-/* harmony import */ var _src_pro_bitget_js__WEBPACK_IMPORTED_MODULE_116__ = __webpack_require__(1885);
-/* harmony import */ var _src_pro_bitmart_js__WEBPACK_IMPORTED_MODULE_117__ = __webpack_require__(7504);
-/* harmony import */ var _src_pro_bitmex_js__WEBPACK_IMPORTED_MODULE_118__ = __webpack_require__(2302);
-/* harmony import */ var _src_pro_bitopro_js__WEBPACK_IMPORTED_MODULE_119__ = __webpack_require__(2191);
-/* harmony import */ var _src_pro_bitpanda_js__WEBPACK_IMPORTED_MODULE_120__ = __webpack_require__(1297);
-/* harmony import */ var _src_pro_bitrue_js__WEBPACK_IMPORTED_MODULE_121__ = __webpack_require__(3005);
-/* harmony import */ var _src_pro_bitstamp_js__WEBPACK_IMPORTED_MODULE_122__ = __webpack_require__(3623);
-/* harmony import */ var _src_pro_bittrex_js__WEBPACK_IMPORTED_MODULE_123__ = __webpack_require__(2883);
-/* harmony import */ var _src_pro_bitvavo_js__WEBPACK_IMPORTED_MODULE_124__ = __webpack_require__(6977);
-/* harmony import */ var _src_pro_blockchaincom_js__WEBPACK_IMPORTED_MODULE_125__ = __webpack_require__(2519);
-/* harmony import */ var _src_pro_bybit_js__WEBPACK_IMPORTED_MODULE_126__ = __webpack_require__(5030);
-/* harmony import */ var _src_pro_cex_js__WEBPACK_IMPORTED_MODULE_127__ = __webpack_require__(5272);
-/* harmony import */ var _src_pro_coinbase_js__WEBPACK_IMPORTED_MODULE_128__ = __webpack_require__(3414);
-/* harmony import */ var _src_pro_coinbaseprime_js__WEBPACK_IMPORTED_MODULE_129__ = __webpack_require__(3848);
-/* harmony import */ var _src_pro_coinbasepro_js__WEBPACK_IMPORTED_MODULE_130__ = __webpack_require__(8368);
-/* harmony import */ var _src_pro_coinex_js__WEBPACK_IMPORTED_MODULE_131__ = __webpack_require__(204);
-/* harmony import */ var _src_pro_cryptocom_js__WEBPACK_IMPORTED_MODULE_132__ = __webpack_require__(6820);
-/* harmony import */ var _src_pro_currencycom_js__WEBPACK_IMPORTED_MODULE_133__ = __webpack_require__(2952);
-/* harmony import */ var _src_pro_deribit_js__WEBPACK_IMPORTED_MODULE_134__ = __webpack_require__(1788);
-/* harmony import */ var _src_pro_exmo_js__WEBPACK_IMPORTED_MODULE_135__ = __webpack_require__(9004);
-/* harmony import */ var _src_pro_gate_js__WEBPACK_IMPORTED_MODULE_136__ = __webpack_require__(8335);
-/* harmony import */ var _src_pro_gateio_js__WEBPACK_IMPORTED_MODULE_137__ = __webpack_require__(1465);
-/* harmony import */ var _src_pro_gemini_js__WEBPACK_IMPORTED_MODULE_138__ = __webpack_require__(9488);
-/* harmony import */ var _src_pro_hitbtc_js__WEBPACK_IMPORTED_MODULE_139__ = __webpack_require__(5189);
-/* harmony import */ var _src_pro_hollaex_js__WEBPACK_IMPORTED_MODULE_140__ = __webpack_require__(8559);
-/* harmony import */ var _src_pro_huobi_js__WEBPACK_IMPORTED_MODULE_141__ = __webpack_require__(8384);
-/* harmony import */ var _src_pro_huobijp_js__WEBPACK_IMPORTED_MODULE_142__ = __webpack_require__(9021);
-/* harmony import */ var _src_pro_huobipro_js__WEBPACK_IMPORTED_MODULE_143__ = __webpack_require__(4625);
-/* harmony import */ var _src_pro_idex_js__WEBPACK_IMPORTED_MODULE_144__ = __webpack_require__(3484);
-/* harmony import */ var _src_pro_independentreserve_js__WEBPACK_IMPORTED_MODULE_145__ = __webpack_require__(1311);
-/* harmony import */ var _src_pro_kraken_js__WEBPACK_IMPORTED_MODULE_146__ = __webpack_require__(736);
-/* harmony import */ var _src_pro_krakenfutures_js__WEBPACK_IMPORTED_MODULE_147__ = __webpack_require__(449);
-/* harmony import */ var _src_pro_kucoin_js__WEBPACK_IMPORTED_MODULE_148__ = __webpack_require__(2387);
-/* harmony import */ var _src_pro_kucoinfutures_js__WEBPACK_IMPORTED_MODULE_149__ = __webpack_require__(7181);
-/* harmony import */ var _src_pro_luno_js__WEBPACK_IMPORTED_MODULE_150__ = __webpack_require__(627);
-/* harmony import */ var _src_pro_mexc_js__WEBPACK_IMPORTED_MODULE_151__ = __webpack_require__(6484);
-/* harmony import */ var _src_pro_mexc3_js__WEBPACK_IMPORTED_MODULE_152__ = __webpack_require__(5351);
-/* harmony import */ var _src_pro_ndax_js__WEBPACK_IMPORTED_MODULE_153__ = __webpack_require__(8080);
-/* harmony import */ var _src_pro_okcoin_js__WEBPACK_IMPORTED_MODULE_154__ = __webpack_require__(7105);
-/* harmony import */ var _src_pro_okex_js__WEBPACK_IMPORTED_MODULE_155__ = __webpack_require__(1530);
-/* harmony import */ var _src_pro_okx_js__WEBPACK_IMPORTED_MODULE_156__ = __webpack_require__(2214);
-/* harmony import */ var _src_pro_phemex_js__WEBPACK_IMPORTED_MODULE_157__ = __webpack_require__(4360);
-/* harmony import */ var _src_pro_poloniex_js__WEBPACK_IMPORTED_MODULE_158__ = __webpack_require__(7924);
-/* harmony import */ var _src_pro_poloniexfutures_js__WEBPACK_IMPORTED_MODULE_159__ = __webpack_require__(3541);
-/* harmony import */ var _src_pro_probit_js__WEBPACK_IMPORTED_MODULE_160__ = __webpack_require__(9782);
-/* harmony import */ var _src_pro_upbit_js__WEBPACK_IMPORTED_MODULE_161__ = __webpack_require__(7614);
-/* harmony import */ var _src_pro_wazirx_js__WEBPACK_IMPORTED_MODULE_162__ = __webpack_require__(4828);
-/* harmony import */ var _src_pro_whitebit_js__WEBPACK_IMPORTED_MODULE_163__ = __webpack_require__(5630);
-/* harmony import */ var _src_pro_woo_js__WEBPACK_IMPORTED_MODULE_164__ = __webpack_require__(3910);
+/* harmony import */ var _src_pro_bingx_js__WEBPACK_IMPORTED_MODULE_113__ = __webpack_require__(6955);
+/* harmony import */ var _src_pro_bitcoincom_js__WEBPACK_IMPORTED_MODULE_114__ = __webpack_require__(453);
+/* harmony import */ var _src_pro_bitfinex_js__WEBPACK_IMPORTED_MODULE_115__ = __webpack_require__(9772);
+/* harmony import */ var _src_pro_bitfinex2_js__WEBPACK_IMPORTED_MODULE_116__ = __webpack_require__(588);
+/* harmony import */ var _src_pro_bitget_js__WEBPACK_IMPORTED_MODULE_117__ = __webpack_require__(1885);
+/* harmony import */ var _src_pro_bitmart_js__WEBPACK_IMPORTED_MODULE_118__ = __webpack_require__(7504);
+/* harmony import */ var _src_pro_bitmex_js__WEBPACK_IMPORTED_MODULE_119__ = __webpack_require__(2302);
+/* harmony import */ var _src_pro_bitopro_js__WEBPACK_IMPORTED_MODULE_120__ = __webpack_require__(2191);
+/* harmony import */ var _src_pro_bitpanda_js__WEBPACK_IMPORTED_MODULE_121__ = __webpack_require__(1297);
+/* harmony import */ var _src_pro_bitrue_js__WEBPACK_IMPORTED_MODULE_122__ = __webpack_require__(3005);
+/* harmony import */ var _src_pro_bitstamp_js__WEBPACK_IMPORTED_MODULE_123__ = __webpack_require__(3623);
+/* harmony import */ var _src_pro_bittrex_js__WEBPACK_IMPORTED_MODULE_124__ = __webpack_require__(2883);
+/* harmony import */ var _src_pro_bitvavo_js__WEBPACK_IMPORTED_MODULE_125__ = __webpack_require__(6977);
+/* harmony import */ var _src_pro_blockchaincom_js__WEBPACK_IMPORTED_MODULE_126__ = __webpack_require__(2519);
+/* harmony import */ var _src_pro_bybit_js__WEBPACK_IMPORTED_MODULE_127__ = __webpack_require__(5030);
+/* harmony import */ var _src_pro_cex_js__WEBPACK_IMPORTED_MODULE_128__ = __webpack_require__(5272);
+/* harmony import */ var _src_pro_coinbase_js__WEBPACK_IMPORTED_MODULE_129__ = __webpack_require__(3414);
+/* harmony import */ var _src_pro_coinbaseprime_js__WEBPACK_IMPORTED_MODULE_130__ = __webpack_require__(3848);
+/* harmony import */ var _src_pro_coinbasepro_js__WEBPACK_IMPORTED_MODULE_131__ = __webpack_require__(8368);
+/* harmony import */ var _src_pro_coinex_js__WEBPACK_IMPORTED_MODULE_132__ = __webpack_require__(204);
+/* harmony import */ var _src_pro_cryptocom_js__WEBPACK_IMPORTED_MODULE_133__ = __webpack_require__(6820);
+/* harmony import */ var _src_pro_currencycom_js__WEBPACK_IMPORTED_MODULE_134__ = __webpack_require__(2952);
+/* harmony import */ var _src_pro_deribit_js__WEBPACK_IMPORTED_MODULE_135__ = __webpack_require__(1788);
+/* harmony import */ var _src_pro_exmo_js__WEBPACK_IMPORTED_MODULE_136__ = __webpack_require__(9004);
+/* harmony import */ var _src_pro_gate_js__WEBPACK_IMPORTED_MODULE_137__ = __webpack_require__(8335);
+/* harmony import */ var _src_pro_gateio_js__WEBPACK_IMPORTED_MODULE_138__ = __webpack_require__(1465);
+/* harmony import */ var _src_pro_gemini_js__WEBPACK_IMPORTED_MODULE_139__ = __webpack_require__(9488);
+/* harmony import */ var _src_pro_hitbtc_js__WEBPACK_IMPORTED_MODULE_140__ = __webpack_require__(5189);
+/* harmony import */ var _src_pro_hollaex_js__WEBPACK_IMPORTED_MODULE_141__ = __webpack_require__(8559);
+/* harmony import */ var _src_pro_huobi_js__WEBPACK_IMPORTED_MODULE_142__ = __webpack_require__(8384);
+/* harmony import */ var _src_pro_huobijp_js__WEBPACK_IMPORTED_MODULE_143__ = __webpack_require__(9021);
+/* harmony import */ var _src_pro_huobipro_js__WEBPACK_IMPORTED_MODULE_144__ = __webpack_require__(4625);
+/* harmony import */ var _src_pro_idex_js__WEBPACK_IMPORTED_MODULE_145__ = __webpack_require__(3484);
+/* harmony import */ var _src_pro_independentreserve_js__WEBPACK_IMPORTED_MODULE_146__ = __webpack_require__(1311);
+/* harmony import */ var _src_pro_kraken_js__WEBPACK_IMPORTED_MODULE_147__ = __webpack_require__(736);
+/* harmony import */ var _src_pro_krakenfutures_js__WEBPACK_IMPORTED_MODULE_148__ = __webpack_require__(449);
+/* harmony import */ var _src_pro_kucoin_js__WEBPACK_IMPORTED_MODULE_149__ = __webpack_require__(2387);
+/* harmony import */ var _src_pro_kucoinfutures_js__WEBPACK_IMPORTED_MODULE_150__ = __webpack_require__(7181);
+/* harmony import */ var _src_pro_luno_js__WEBPACK_IMPORTED_MODULE_151__ = __webpack_require__(627);
+/* harmony import */ var _src_pro_mexc_js__WEBPACK_IMPORTED_MODULE_152__ = __webpack_require__(6484);
+/* harmony import */ var _src_pro_mexc3_js__WEBPACK_IMPORTED_MODULE_153__ = __webpack_require__(5351);
+/* harmony import */ var _src_pro_ndax_js__WEBPACK_IMPORTED_MODULE_154__ = __webpack_require__(8080);
+/* harmony import */ var _src_pro_okcoin_js__WEBPACK_IMPORTED_MODULE_155__ = __webpack_require__(7105);
+/* harmony import */ var _src_pro_okex_js__WEBPACK_IMPORTED_MODULE_156__ = __webpack_require__(1530);
+/* harmony import */ var _src_pro_okx_js__WEBPACK_IMPORTED_MODULE_157__ = __webpack_require__(2214);
+/* harmony import */ var _src_pro_phemex_js__WEBPACK_IMPORTED_MODULE_158__ = __webpack_require__(4360);
+/* harmony import */ var _src_pro_poloniex_js__WEBPACK_IMPORTED_MODULE_159__ = __webpack_require__(7924);
+/* harmony import */ var _src_pro_poloniexfutures_js__WEBPACK_IMPORTED_MODULE_160__ = __webpack_require__(3541);
+/* harmony import */ var _src_pro_probit_js__WEBPACK_IMPORTED_MODULE_161__ = __webpack_require__(9782);
+/* harmony import */ var _src_pro_upbit_js__WEBPACK_IMPORTED_MODULE_162__ = __webpack_require__(7614);
+/* harmony import */ var _src_pro_wazirx_js__WEBPACK_IMPORTED_MODULE_163__ = __webpack_require__(4828);
+/* harmony import */ var _src_pro_whitebit_js__WEBPACK_IMPORTED_MODULE_164__ = __webpack_require__(5630);
+/* harmony import */ var _src_pro_woo_js__WEBPACK_IMPORTED_MODULE_165__ = __webpack_require__(3910);
 /*
 
 MIT License
@@ -275264,7 +276313,7 @@ SOFTWARE.
 
 //-----------------------------------------------------------------------------
 // this is updated by vss.js when building
-const version = '4.1.8';
+const version = '4.1.9';
 _src_base_Exchange_js__WEBPACK_IMPORTED_MODULE_0__/* .Exchange.ccxtVersion */ .e.ccxtVersion = version;
 //-----------------------------------------------------------------------------
 
@@ -275430,6 +276479,7 @@ _src_base_Exchange_js__WEBPACK_IMPORTED_MODULE_0__/* .Exchange.ccxtVersion */ .e
 
 
 
+
 
 
 const exchanges = {
@@ -275547,58 +276597,59 @@ const pro = {
     'binancecoinm': _src_pro_binancecoinm_js__WEBPACK_IMPORTED_MODULE_110__/* ["default"] */ .Z,
     'binanceus': _src_pro_binanceus_js__WEBPACK_IMPORTED_MODULE_111__/* ["default"] */ .Z,
     'binanceusdm': _src_pro_binanceusdm_js__WEBPACK_IMPORTED_MODULE_112__/* ["default"] */ .Z,
-    'bitcoincom': _src_pro_bitcoincom_js__WEBPACK_IMPORTED_MODULE_113__/* ["default"] */ .Z,
-    'bitfinex': _src_pro_bitfinex_js__WEBPACK_IMPORTED_MODULE_114__/* ["default"] */ .Z,
-    'bitfinex2': _src_pro_bitfinex2_js__WEBPACK_IMPORTED_MODULE_115__/* ["default"] */ .Z,
-    'bitget': _src_pro_bitget_js__WEBPACK_IMPORTED_MODULE_116__/* ["default"] */ .Z,
-    'bitmart': _src_pro_bitmart_js__WEBPACK_IMPORTED_MODULE_117__/* ["default"] */ .Z,
-    'bitmex': _src_pro_bitmex_js__WEBPACK_IMPORTED_MODULE_118__/* ["default"] */ .Z,
-    'bitopro': _src_pro_bitopro_js__WEBPACK_IMPORTED_MODULE_119__/* ["default"] */ .Z,
-    'bitpanda': _src_pro_bitpanda_js__WEBPACK_IMPORTED_MODULE_120__/* ["default"] */ .Z,
-    'bitrue': _src_pro_bitrue_js__WEBPACK_IMPORTED_MODULE_121__/* ["default"] */ .Z,
-    'bitstamp': _src_pro_bitstamp_js__WEBPACK_IMPORTED_MODULE_122__/* ["default"] */ .Z,
-    'bittrex': _src_pro_bittrex_js__WEBPACK_IMPORTED_MODULE_123__/* ["default"] */ .Z,
-    'bitvavo': _src_pro_bitvavo_js__WEBPACK_IMPORTED_MODULE_124__/* ["default"] */ .Z,
-    'blockchaincom': _src_pro_blockchaincom_js__WEBPACK_IMPORTED_MODULE_125__/* ["default"] */ .Z,
-    'bybit': _src_pro_bybit_js__WEBPACK_IMPORTED_MODULE_126__/* ["default"] */ .Z,
-    'cex': _src_pro_cex_js__WEBPACK_IMPORTED_MODULE_127__/* ["default"] */ .Z,
-    'coinbase': _src_pro_coinbase_js__WEBPACK_IMPORTED_MODULE_128__/* ["default"] */ .Z,
-    'coinbaseprime': _src_pro_coinbaseprime_js__WEBPACK_IMPORTED_MODULE_129__/* ["default"] */ .Z,
-    'coinbasepro': _src_pro_coinbasepro_js__WEBPACK_IMPORTED_MODULE_130__/* ["default"] */ .Z,
-    'coinex': _src_pro_coinex_js__WEBPACK_IMPORTED_MODULE_131__/* ["default"] */ .Z,
-    'cryptocom': _src_pro_cryptocom_js__WEBPACK_IMPORTED_MODULE_132__/* ["default"] */ .Z,
-    'currencycom': _src_pro_currencycom_js__WEBPACK_IMPORTED_MODULE_133__/* ["default"] */ .Z,
-    'deribit': _src_pro_deribit_js__WEBPACK_IMPORTED_MODULE_134__/* ["default"] */ .Z,
-    'exmo': _src_pro_exmo_js__WEBPACK_IMPORTED_MODULE_135__/* ["default"] */ .Z,
-    'gate': _src_pro_gate_js__WEBPACK_IMPORTED_MODULE_136__/* ["default"] */ .Z,
-    'gateio': _src_pro_gateio_js__WEBPACK_IMPORTED_MODULE_137__/* ["default"] */ .Z,
-    'gemini': _src_pro_gemini_js__WEBPACK_IMPORTED_MODULE_138__/* ["default"] */ .Z,
-    'hitbtc': _src_pro_hitbtc_js__WEBPACK_IMPORTED_MODULE_139__/* ["default"] */ .Z,
-    'hollaex': _src_pro_hollaex_js__WEBPACK_IMPORTED_MODULE_140__/* ["default"] */ .Z,
-    'huobi': _src_pro_huobi_js__WEBPACK_IMPORTED_MODULE_141__/* ["default"] */ .Z,
-    'huobijp': _src_pro_huobijp_js__WEBPACK_IMPORTED_MODULE_142__/* ["default"] */ .Z,
-    'huobipro': _src_pro_huobipro_js__WEBPACK_IMPORTED_MODULE_143__/* ["default"] */ .Z,
-    'idex': _src_pro_idex_js__WEBPACK_IMPORTED_MODULE_144__/* ["default"] */ .Z,
-    'independentreserve': _src_pro_independentreserve_js__WEBPACK_IMPORTED_MODULE_145__/* ["default"] */ .Z,
-    'kraken': _src_pro_kraken_js__WEBPACK_IMPORTED_MODULE_146__/* ["default"] */ .Z,
-    'krakenfutures': _src_pro_krakenfutures_js__WEBPACK_IMPORTED_MODULE_147__/* ["default"] */ .Z,
-    'kucoin': _src_pro_kucoin_js__WEBPACK_IMPORTED_MODULE_148__/* ["default"] */ .Z,
-    'kucoinfutures': _src_pro_kucoinfutures_js__WEBPACK_IMPORTED_MODULE_149__/* ["default"] */ .Z,
-    'luno': _src_pro_luno_js__WEBPACK_IMPORTED_MODULE_150__/* ["default"] */ .Z,
-    'mexc': _src_pro_mexc_js__WEBPACK_IMPORTED_MODULE_151__/* ["default"] */ .Z,
-    'mexc3': _src_pro_mexc3_js__WEBPACK_IMPORTED_MODULE_152__/* ["default"] */ .Z,
-    'ndax': _src_pro_ndax_js__WEBPACK_IMPORTED_MODULE_153__/* ["default"] */ .Z,
-    'okcoin': _src_pro_okcoin_js__WEBPACK_IMPORTED_MODULE_154__/* ["default"] */ .Z,
-    'okex': _src_pro_okex_js__WEBPACK_IMPORTED_MODULE_155__/* ["default"] */ .Z,
-    'okx': _src_pro_okx_js__WEBPACK_IMPORTED_MODULE_156__/* ["default"] */ .Z,
-    'phemex': _src_pro_phemex_js__WEBPACK_IMPORTED_MODULE_157__/* ["default"] */ .Z,
-    'poloniex': _src_pro_poloniex_js__WEBPACK_IMPORTED_MODULE_158__/* ["default"] */ .Z,
-    'poloniexfutures': _src_pro_poloniexfutures_js__WEBPACK_IMPORTED_MODULE_159__/* ["default"] */ .Z,
-    'probit': _src_pro_probit_js__WEBPACK_IMPORTED_MODULE_160__/* ["default"] */ .Z,
-    'upbit': _src_pro_upbit_js__WEBPACK_IMPORTED_MODULE_161__/* ["default"] */ .Z,
-    'wazirx': _src_pro_wazirx_js__WEBPACK_IMPORTED_MODULE_162__/* ["default"] */ .Z,
-    'whitebit': _src_pro_whitebit_js__WEBPACK_IMPORTED_MODULE_163__/* ["default"] */ .Z,
-    'woo': _src_pro_woo_js__WEBPACK_IMPORTED_MODULE_164__/* ["default"] */ .Z,
+    'bingx': _src_pro_bingx_js__WEBPACK_IMPORTED_MODULE_113__/* ["default"] */ .Z,
+    'bitcoincom': _src_pro_bitcoincom_js__WEBPACK_IMPORTED_MODULE_114__/* ["default"] */ .Z,
+    'bitfinex': _src_pro_bitfinex_js__WEBPACK_IMPORTED_MODULE_115__/* ["default"] */ .Z,
+    'bitfinex2': _src_pro_bitfinex2_js__WEBPACK_IMPORTED_MODULE_116__/* ["default"] */ .Z,
+    'bitget': _src_pro_bitget_js__WEBPACK_IMPORTED_MODULE_117__/* ["default"] */ .Z,
+    'bitmart': _src_pro_bitmart_js__WEBPACK_IMPORTED_MODULE_118__/* ["default"] */ .Z,
+    'bitmex': _src_pro_bitmex_js__WEBPACK_IMPORTED_MODULE_119__/* ["default"] */ .Z,
+    'bitopro': _src_pro_bitopro_js__WEBPACK_IMPORTED_MODULE_120__/* ["default"] */ .Z,
+    'bitpanda': _src_pro_bitpanda_js__WEBPACK_IMPORTED_MODULE_121__/* ["default"] */ .Z,
+    'bitrue': _src_pro_bitrue_js__WEBPACK_IMPORTED_MODULE_122__/* ["default"] */ .Z,
+    'bitstamp': _src_pro_bitstamp_js__WEBPACK_IMPORTED_MODULE_123__/* ["default"] */ .Z,
+    'bittrex': _src_pro_bittrex_js__WEBPACK_IMPORTED_MODULE_124__/* ["default"] */ .Z,
+    'bitvavo': _src_pro_bitvavo_js__WEBPACK_IMPORTED_MODULE_125__/* ["default"] */ .Z,
+    'blockchaincom': _src_pro_blockchaincom_js__WEBPACK_IMPORTED_MODULE_126__/* ["default"] */ .Z,
+    'bybit': _src_pro_bybit_js__WEBPACK_IMPORTED_MODULE_127__/* ["default"] */ .Z,
+    'cex': _src_pro_cex_js__WEBPACK_IMPORTED_MODULE_128__/* ["default"] */ .Z,
+    'coinbase': _src_pro_coinbase_js__WEBPACK_IMPORTED_MODULE_129__/* ["default"] */ .Z,
+    'coinbaseprime': _src_pro_coinbaseprime_js__WEBPACK_IMPORTED_MODULE_130__/* ["default"] */ .Z,
+    'coinbasepro': _src_pro_coinbasepro_js__WEBPACK_IMPORTED_MODULE_131__/* ["default"] */ .Z,
+    'coinex': _src_pro_coinex_js__WEBPACK_IMPORTED_MODULE_132__/* ["default"] */ .Z,
+    'cryptocom': _src_pro_cryptocom_js__WEBPACK_IMPORTED_MODULE_133__/* ["default"] */ .Z,
+    'currencycom': _src_pro_currencycom_js__WEBPACK_IMPORTED_MODULE_134__/* ["default"] */ .Z,
+    'deribit': _src_pro_deribit_js__WEBPACK_IMPORTED_MODULE_135__/* ["default"] */ .Z,
+    'exmo': _src_pro_exmo_js__WEBPACK_IMPORTED_MODULE_136__/* ["default"] */ .Z,
+    'gate': _src_pro_gate_js__WEBPACK_IMPORTED_MODULE_137__/* ["default"] */ .Z,
+    'gateio': _src_pro_gateio_js__WEBPACK_IMPORTED_MODULE_138__/* ["default"] */ .Z,
+    'gemini': _src_pro_gemini_js__WEBPACK_IMPORTED_MODULE_139__/* ["default"] */ .Z,
+    'hitbtc': _src_pro_hitbtc_js__WEBPACK_IMPORTED_MODULE_140__/* ["default"] */ .Z,
+    'hollaex': _src_pro_hollaex_js__WEBPACK_IMPORTED_MODULE_141__/* ["default"] */ .Z,
+    'huobi': _src_pro_huobi_js__WEBPACK_IMPORTED_MODULE_142__/* ["default"] */ .Z,
+    'huobijp': _src_pro_huobijp_js__WEBPACK_IMPORTED_MODULE_143__/* ["default"] */ .Z,
+    'huobipro': _src_pro_huobipro_js__WEBPACK_IMPORTED_MODULE_144__/* ["default"] */ .Z,
+    'idex': _src_pro_idex_js__WEBPACK_IMPORTED_MODULE_145__/* ["default"] */ .Z,
+    'independentreserve': _src_pro_independentreserve_js__WEBPACK_IMPORTED_MODULE_146__/* ["default"] */ .Z,
+    'kraken': _src_pro_kraken_js__WEBPACK_IMPORTED_MODULE_147__/* ["default"] */ .Z,
+    'krakenfutures': _src_pro_krakenfutures_js__WEBPACK_IMPORTED_MODULE_148__/* ["default"] */ .Z,
+    'kucoin': _src_pro_kucoin_js__WEBPACK_IMPORTED_MODULE_149__/* ["default"] */ .Z,
+    'kucoinfutures': _src_pro_kucoinfutures_js__WEBPACK_IMPORTED_MODULE_150__/* ["default"] */ .Z,
+    'luno': _src_pro_luno_js__WEBPACK_IMPORTED_MODULE_151__/* ["default"] */ .Z,
+    'mexc': _src_pro_mexc_js__WEBPACK_IMPORTED_MODULE_152__/* ["default"] */ .Z,
+    'mexc3': _src_pro_mexc3_js__WEBPACK_IMPORTED_MODULE_153__/* ["default"] */ .Z,
+    'ndax': _src_pro_ndax_js__WEBPACK_IMPORTED_MODULE_154__/* ["default"] */ .Z,
+    'okcoin': _src_pro_okcoin_js__WEBPACK_IMPORTED_MODULE_155__/* ["default"] */ .Z,
+    'okex': _src_pro_okex_js__WEBPACK_IMPORTED_MODULE_156__/* ["default"] */ .Z,
+    'okx': _src_pro_okx_js__WEBPACK_IMPORTED_MODULE_157__/* ["default"] */ .Z,
+    'phemex': _src_pro_phemex_js__WEBPACK_IMPORTED_MODULE_158__/* ["default"] */ .Z,
+    'poloniex': _src_pro_poloniex_js__WEBPACK_IMPORTED_MODULE_159__/* ["default"] */ .Z,
+    'poloniexfutures': _src_pro_poloniexfutures_js__WEBPACK_IMPORTED_MODULE_160__/* ["default"] */ .Z,
+    'probit': _src_pro_probit_js__WEBPACK_IMPORTED_MODULE_161__/* ["default"] */ .Z,
+    'upbit': _src_pro_upbit_js__WEBPACK_IMPORTED_MODULE_162__/* ["default"] */ .Z,
+    'wazirx': _src_pro_wazirx_js__WEBPACK_IMPORTED_MODULE_163__/* ["default"] */ .Z,
+    'whitebit': _src_pro_whitebit_js__WEBPACK_IMPORTED_MODULE_164__/* ["default"] */ .Z,
+    'woo': _src_pro_woo_js__WEBPACK_IMPORTED_MODULE_165__/* ["default"] */ .Z,
 };
 for (const exchange in pro) {
     // const ccxtExchange = exchanges[exchange]
@@ -275611,7 +276662,7 @@ for (const exchange in pro) {
 pro.exchanges = Object.keys(pro);
 pro['Exchange'] = _src_base_Exchange_js__WEBPACK_IMPORTED_MODULE_0__/* .Exchange */ .e; // now the same for rest and ts
 //-----------------------------------------------------------------------------
-const ccxt = Object.assign({ version, Exchange: _src_base_Exchange_js__WEBPACK_IMPORTED_MODULE_0__/* .Exchange */ .e, Precise: _src_base_Precise_js__WEBPACK_IMPORTED_MODULE_165__/* .Precise */ .O, 'exchanges': Object.keys(exchanges), 'pro': pro }, exchanges, _src_base_functions_js__WEBPACK_IMPORTED_MODULE_166__, _src_base_errors_js__WEBPACK_IMPORTED_MODULE_167__);
+const ccxt = Object.assign({ version, Exchange: _src_base_Exchange_js__WEBPACK_IMPORTED_MODULE_0__/* .Exchange */ .e, Precise: _src_base_Precise_js__WEBPACK_IMPORTED_MODULE_166__/* .Precise */ .O, 'exchanges': Object.keys(exchanges), 'pro': pro }, exchanges, _src_base_functions_js__WEBPACK_IMPORTED_MODULE_167__, _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__);
 
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (ccxt);
 //-----------------------------------------------------------------------------