ccxt 4.2.37 → 4.2.38

package/dist/ccxt.browser.js

@@ -400,6 +400,22 @@ class Exchange extends _base_Exchange_js__WEBPACK_IMPORTED_MODULE_0__/* .Exchang
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Exchange);
 
 
+/***/ }),
+
+/***/ 6065:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Z: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _base_Exchange_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3043);
+// -------------------------------------------------------------------------------
+
+class Exchange extends _base_Exchange_js__WEBPACK_IMPORTED_MODULE_0__/* .Exchange */ .e {
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Exchange);
+
+
 /***/ }),
 
 /***/ 5489:
@@ -75480,6 +75496,2119 @@ class blockchaincom extends _abstract_blockchaincom_js__WEBPACK_IMPORTED_MODULE_
 }
 
 
+/***/ }),
+
+/***/ 687:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Z: () => (/* binding */ blofin)
+/* harmony export */ });
+/* harmony import */ var _abstract_blofin_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(6065);
+/* harmony import */ var _base_errors_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6689);
+/* harmony import */ var _base_Precise_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(2194);
+/* harmony import */ var _base_functions_number_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(9292);
+/* harmony import */ var _static_dependencies_noble_hashes_sha256_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(1372);
+//  ---------------------------------------------------------------------------
+
+
+
+
+
+//  ---------------------------------------------------------------------------
+/**
+ * @class blofin
+ * @augments Exchange
+ */
+class blofin extends _abstract_blofin_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z {
+    describe() {
+        return this.deepExtend(super.describe(), {
+            'id': 'blofin',
+            'name': 'BloFin',
+            'countries': ['US'],
+            'version': 'v1',
+            'rateLimit': 100,
+            'has': {
+                'CORS': undefined,
+                'spot': false,
+                'margin': false,
+                'swap': true,
+                'future': false,
+                'option': false,
+                'addMargin': false,
+                'borrowMargin': false,
+                'cancelAllOrders': false,
+                'cancelOrder': true,
+                'cancelOrders': true,
+                'closeAllPositions': false,
+                'closePosition': true,
+                'createDepositAddress': false,
+                'createMarketBuyOrderWithCost': false,
+                'createMarketSellOrderWithCost': false,
+                'createOrder': true,
+                'createOrders': true,
+                'createOrderWithTakeProfitAndStopLoss': true,
+                'createPostOnlyOrder': false,
+                'createReduceOnlyOrder': false,
+                'createStopLimitOrder': false,
+                'createStopLossOrder': true,
+                'createStopMarketOrder': false,
+                'createStopOrder': false,
+                'createTakeProfitOrder': true,
+                'editOrder': false,
+                'fetchAccounts': false,
+                'fetchBalance': true,
+                'fetchBidsAsks': undefined,
+                'fetchBorrowInterest': false,
+                'fetchBorrowRateHistories': false,
+                'fetchBorrowRateHistory': false,
+                'fetchCanceledOrders': false,
+                'fetchClosedOrder': false,
+                'fetchClosedOrders': false,
+                'fetchCrossBorrowRate': false,
+                'fetchCrossBorrowRates': false,
+                'fetchCurrencies': false,
+                'fetchDeposit': false,
+                'fetchDepositAddress': false,
+                'fetchDepositAddresses': false,
+                'fetchDepositAddressesByNetwork': false,
+                'fetchDeposits': true,
+                'fetchDepositsWithdrawals': false,
+                'fetchDepositWithdrawFee': 'emulated',
+                'fetchDepositWithdrawFees': false,
+                'fetchFundingHistory': true,
+                'fetchFundingRate': true,
+                'fetchFundingRateHistory': true,
+                'fetchFundingRates': false,
+                'fetchGreeks': false,
+                'fetchIndexOHLCV': false,
+                'fetchIsolatedBorrowRate': false,
+                'fetchIsolatedBorrowRates': false,
+                'fetchL3OrderBook': false,
+                'fetchLedger': true,
+                'fetchLedgerEntry': undefined,
+                'fetchLeverage': true,
+                'fetchLeverageTiers': false,
+                'fetchMarketLeverageTiers': false,
+                'fetchMarkets': true,
+                'fetchMarkOHLCV': false,
+                'fetchMySettlementHistory': false,
+                'fetchMyTrades': true,
+                'fetchOHLCV': true,
+                'fetchOpenInterest': false,
+                'fetchOpenInterestHistory': false,
+                'fetchOpenOrder': undefined,
+                'fetchOpenOrders': true,
+                'fetchOrder': true,
+                'fetchOrderBook': true,
+                'fetchOrderBooks': false,
+                'fetchOrders': false,
+                'fetchOrderTrades': true,
+                'fetchPermissions': undefined,
+                'fetchPosition': true,
+                'fetchPositions': true,
+                'fetchPositionsForSymbol': false,
+                'fetchPositionsRisk': false,
+                'fetchPremiumIndexOHLCV': false,
+                'fetchSettlementHistory': false,
+                'fetchStatus': false,
+                'fetchTicker': true,
+                'fetchTickers': true,
+                'fetchTime': false,
+                'fetchTrades': true,
+                'fetchTradingFee': false,
+                'fetchTradingFees': false,
+                'fetchTradingLimits': false,
+                'fetchTransactionFee': false,
+                'fetchTransactionFees': false,
+                'fetchTransactions': false,
+                'fetchTransfer': false,
+                'fetchTransfers': false,
+                'fetchUnderlyingAssets': false,
+                'fetchVolatilityHistory': false,
+                'fetchWithdrawal': false,
+                'fetchWithdrawals': true,
+                'fetchWithdrawalWhitelist': false,
+                'reduceMargin': false,
+                'repayCrossMargin': false,
+                'setLeverage': true,
+                'setMargin': false,
+                'setMarginMode': false,
+                'setPositionMode': false,
+                'signIn': false,
+                'transfer': true,
+                'withdraw': false,
+            },
+            'timeframes': {
+                '1m': '1m',
+                '3m': '3m',
+                '5m': '5m',
+                '15m': '15m',
+                '30m': '30m',
+                '1h': '1H',
+                '2h': '2H',
+                '4h': '4H',
+                '6h': '6H',
+                '12h': '12H',
+                '1d': '1D',
+                '1w': '1W',
+                '1M': '1M',
+                '3M': '3M',
+            },
+            'hostname': 'www.blofin.com',
+            'urls': {
+                'logo': 'https://github.com/ccxt/ccxt/assets/43336371/255a7b29-341f-4d20-8342-fbfae4932807',
+                'api': {
+                    'rest': 'https://openapi.blofin.com',
+                },
+                'referral': {
+                    'url': 'https://blofin.com/register?referral_code=jBd8U1',
+                    'discount': 0.05,
+                },
+                'www': 'https://www.blofin.com',
+                'doc': 'https://blofin.com/docs',
+            },
+            'api': {
+                'public': {
+                    'get': {
+                        'market/instruments': 1,
+                        'market/tickers': 1,
+                        'market/books': 1,
+                        'market/trades': 1,
+                        'market/candles': 1,
+                        'market/mark-price': 1,
+                        'market/funding-rate': 1,
+                        'market/funding-rate-history': 1,
+                    },
+                },
+                'private': {
+                    'get': {
+                        'asset/balances': 1,
+                        'trade/orders-pending': 1,
+                        'trade/fills-history': 1,
+                        'asset/deposit-history': 1,
+                        'asset/withdrawal-history': 1,
+                        'asset/bills': 1,
+                        'account/balance': 1,
+                        'account/positions': 1,
+                        'account/leverage-info': 1,
+                        'trade/orders-tpsl-pending': 1,
+                        'trade/orders-history': 1,
+                        'trade/orders-tpsl-history': 1,
+                    },
+                    'post': {
+                        'trade/order': 1,
+                        'trade/cancel-order': 1,
+                        'account/set-leverage': 1,
+                        'trade/batch-orders': 1,
+                        'trade/order-tpsl': 1,
+                        'trade/cancel-batch-orders': 1,
+                        'trade/cancel-tpsl': 1,
+                        'trade/close-position': 1,
+                        'asset/transfer': 1,
+                    },
+                },
+            },
+            'fees': {
+                'swap': {
+                    'taker': this.parseNumber('0.00060'),
+                    'maker': this.parseNumber('0.00020'),
+                },
+            },
+            'requiredCredentials': {
+                'apiKey': true,
+                'secret': true,
+                'password': true,
+            },
+            'exceptions': {
+                'exact': {
+                    '400': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.BadRequest,
+                    '401': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.AuthenticationError,
+                    '500': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.ExchangeError,
+                    '404': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.BadRequest,
+                    '405': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.BadRequest,
+                    '406': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.BadRequest,
+                    '429': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.RateLimitExceeded,
+                    '152001': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.BadRequest,
+                    '152002': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.BadRequest,
+                    '152003': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.BadRequest,
+                    '152004': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.BadRequest,
+                    '152005': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.BadRequest,
+                    '152006': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.InvalidOrder,
+                    '152007': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.InvalidOrder,
+                    '152008': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.InvalidOrder,
+                    '152009': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.InvalidOrder,
+                    '150003': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.InvalidOrder,
+                    '150004': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.InvalidOrder,
+                    '542': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.InvalidOrder,
+                    '102002': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.InvalidOrder,
+                    '102005': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.InvalidOrder,
+                    '102014': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.InvalidOrder,
+                    '102015': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.InvalidOrder,
+                    '102022': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.InvalidOrder,
+                    '102037': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.InvalidOrder,
+                    '102038': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.InvalidOrder,
+                    '102039': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.InvalidOrder,
+                    '102040': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.InvalidOrder,
+                    '102047': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.InvalidOrder,
+                    '102048': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.InvalidOrder,
+                    '102049': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.InvalidOrder,
+                    '102050': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.InvalidOrder,
+                    '102051': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.InvalidOrder,
+                    '102052': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.InvalidOrder,
+                    '102053': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.InvalidOrder,
+                    '102054': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.InvalidOrder,
+                    '102055': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.InvalidOrder,
+                    '102064': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.BadRequest,
+                    '102065': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.BadRequest,
+                    '102068': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.BadRequest,
+                    '103013': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.ExchangeError,
+                    'Order failed. Insufficient USDT margin in account': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.InsufficientFunds, // Insufficient USDT margin in account
+                },
+                'broad': {
+                    'Internal Server Error': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.ExchangeNotAvailable,
+                    'server error': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.ExchangeNotAvailable, // {"code":500,"data":{},"detailMsg":"","error_code":"500","error_message":"server error 1236805249","msg":"server error 1236805249"}
+                },
+            },
+            'httpExceptions': {
+                '429': _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.ExchangeNotAvailable, // https://github.com/ccxt/ccxt/issues/9612
+            },
+            'precisionMode': _base_functions_number_js__WEBPACK_IMPORTED_MODULE_2__/* .TICK_SIZE */ .sh,
+            'options': {
+                'brokerId': 'ec6dd3a7dd982d0b',
+                'accountsByType': {
+                    'swap': 'futures',
+                    'future': 'futures',
+                },
+                'accountsById': {
+                    'futures': 'swap',
+                },
+                'sandboxMode': false,
+                'defaultNetwork': 'ERC20',
+                'defaultNetworks': {
+                    'ETH': 'ERC20',
+                    'BTC': 'BTC',
+                    'USDT': 'TRC20',
+                },
+                'networks': {
+                    'BTC': 'Bitcoin',
+                    'BEP20': 'BSC',
+                    'ERC20': 'ERC20',
+                    'TRC20': 'TRC20',
+                },
+                'fetchOpenInterestHistory': {
+                    'timeframes': {
+                        '5m': '5m',
+                        '1h': '1H',
+                        '8h': '8H',
+                        '1d': '1D',
+                        '5M': '5m',
+                        '1H': '1H',
+                        '8H': '8H',
+                        '1D': '1D',
+                    },
+                },
+                'fetchOHLCV': {
+                    // 'type': 'Candles', // Candles or HistoryCandles, IndexCandles, MarkPriceCandles
+                    'timezone': 'UTC', // UTC, HK
+                },
+                'fetchPositions': {
+                    'method': 'privateGetAccountPositions', // privateGetAccountPositions or privateGetAccountPositionsHistory
+                },
+                'createOrder': 'privatePostTradeOrder',
+                'createMarketBuyOrderRequiresPrice': false,
+                'fetchMarkets': ['swap'],
+                'defaultType': 'swap',
+                'fetchLedger': {
+                    'method': 'privateGetAssetBills',
+                },
+                'fetchOpenOrders': {
+                    'method': 'privateGetTradeOrdersPending',
+                },
+                'cancelOrders': {
+                    'method': 'privatePostTradeCancelBatchOrders',
+                },
+                'fetchCanceledOrders': {
+                    'method': 'privateGetTradeOrdersHistory', // privateGetTradeOrdersTpslHistory
+                },
+                'fetchClosedOrders': {
+                    'method': 'privateGetTradeOrdersHistory', // privateGetTradeOrdersTpslHistory
+                },
+                'withdraw': {
+                    // a funding password credential is required by the exchange for the
+                    // withdraw call (not to be confused with the api password credential)
+                    'password': undefined,
+                    'pwd': undefined, // password or pwd both work
+                },
+                'exchangeType': {
+                    'spot': 'SPOT',
+                    'swap': 'SWAP',
+                    'SPOT': 'SPOT',
+                    'SWAP': 'SWAP',
+                },
+            },
+        });
+    }
+    async fetchMarkets(params = {}) {
+        /**
+         * @method
+         * @name blofin#fetchMarkets
+         * @description retrieves data on all markets for blofin
+         * @see https://blofin.com/docs#get-instruments
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object[]} an array of objects representing market data
+         */
+        const response = await this.publicGetMarketInstruments(params);
+        const data = this.safeList(response, 'data', []);
+        return this.parseMarkets(data);
+    }
+    parseMarket(market) {
+        const id = this.safeString(market, 'instId');
+        const type = this.safeStringLower(market, 'instType');
+        const spot = (type === 'spot');
+        const future = (type === 'future');
+        const swap = (type === 'swap');
+        const option = (type === 'option');
+        const contract = swap || future;
+        const baseId = this.safeString(market, 'baseCurrency');
+        const quoteId = this.safeString(market, 'quoteCurrency');
+        const settleId = this.safeString(market, 'quoteCurrency');
+        const settle = this.safeCurrencyCode(settleId);
+        const base = this.safeCurrencyCode(baseId);
+        const quote = this.safeCurrencyCode(quoteId);
+        let symbol = base + '/' + quote;
+        if (swap) {
+            symbol = symbol + ':' + settle;
+        }
+        const expiry = undefined;
+        const strikePrice = undefined;
+        const optionType = undefined;
+        const tickSize = this.safeString(market, 'tickSize');
+        const fees = this.safeValue2(this.fees, type, 'trading', {});
+        const taker = this.safeNumber(fees, 'taker');
+        const maker = this.safeNumber(fees, 'maker');
+        let maxLeverage = this.safeString(market, 'maxLeverage', '100');
+        maxLeverage = _base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise */ .O.stringMax(maxLeverage, '1');
+        const isActive = (this.safeString(market, 'state') === 'live');
+        return this.safeMarketStructure({
+            'id': id,
+            'symbol': symbol,
+            'base': base,
+            'quote': quote,
+            'baseId': baseId,
+            'quoteId': quoteId,
+            'settle': settle,
+            'settleId': settleId,
+            'type': type,
+            'spot': spot,
+            'option': option,
+            'margin': spot && (_base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise */ .O.stringGt(maxLeverage, '1')),
+            'swap': swap,
+            'future': future,
+            'active': isActive,
+            'taker': taker,
+            'maker': maker,
+            'contract': contract,
+            'linear': contract ? (quoteId === settleId) : undefined,
+            'inverse': contract ? (baseId === settleId) : undefined,
+            'contractSize': contract ? this.safeNumber(market, 'contractValue') : undefined,
+            'expiry': expiry,
+            'expiryDatetime': expiry,
+            'strike': strikePrice,
+            'optionType': optionType,
+            'created': this.safeInteger(market, 'listTime'),
+            'precision': {
+                'amount': this.safeNumber(market, 'lotSize'),
+                'price': this.parseNumber(tickSize),
+            },
+            'limits': {
+                'leverage': {
+                    'min': this.parseNumber('1'),
+                    'max': this.parseNumber(maxLeverage),
+                },
+                'amount': {
+                    'min': this.safeNumber(market, 'minSize'),
+                    'max': undefined,
+                },
+                'price': {
+                    'min': undefined,
+                    'max': undefined,
+                },
+                'cost': {
+                    'min': undefined,
+                    'max': undefined,
+                },
+            },
+            'info': market,
+        });
+    }
+    async fetchOrderBook(symbol, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name blofin#fetchOrderBook
+         * @description fetches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
+         * @see https://blofin.com/docs#get-order-book
+         * @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 exchange API endpoint
+         * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
+         */
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const request = {
+            'instId': market['id'],
+        };
+        limit = (limit === undefined) ? 50 : limit;
+        if (limit !== undefined) {
+            request['size'] = limit; // max 100
+        }
+        const response = await this.publicGetMarketBooks(this.extend(request, params));
+        //
+        //     {
+        //         "code": "0",
+        //         "msg": "",
+        //         "data": [
+        //             {
+        //                 "asks": [
+        //                     ["0.07228","4.211619","0","2"], // price, amount, liquidated orders, total open orders
+        //                     ["0.0723","299.880364","0","2"],
+        //                     ["0.07231","3.72832","0","1"],
+        //                 ],
+        //                 "bids": [
+        //                     ["0.07221","18.5","0","1"],
+        //                     ["0.0722","18.5","0","1"],
+        //                     ["0.07219","0.505407","0","1"],
+        //                 ],
+        //                 "ts": "1621438475342"
+        //             }
+        //         ]
+        //     }
+        //
+        const data = this.safeList(response, 'data', []);
+        const first = this.safeValue(data, 0, {});
+        const timestamp = this.safeInteger(first, 'ts');
+        return this.parseOrderBook(first, symbol, timestamp);
+    }
+    parseTicker(ticker, market = undefined) {
+        const timestamp = this.safeInteger(ticker, 'ts');
+        const marketId = this.safeString(ticker, 'instId');
+        market = this.safeMarket(marketId, market, '-');
+        const symbol = market['symbol'];
+        const last = this.safeString(ticker, 'last');
+        const open = this.safeString(ticker, 'open24h');
+        const spot = this.safeValue(market, 'spot', false);
+        const quoteVolume = spot ? this.safeString(ticker, 'volCurrency24h') : undefined;
+        const baseVolume = this.safeString(ticker, 'vol24h');
+        const high = this.safeString(ticker, 'high24h');
+        const low = this.safeString(ticker, 'low24h');
+        return this.safeTicker({
+            'symbol': symbol,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'high': high,
+            'low': low,
+            'bid': this.safeString(ticker, 'bidPrice'),
+            'bidVolume': this.safeString(ticker, 'bidSize'),
+            'ask': this.safeString(ticker, 'askPrice'),
+            'askVolume': this.safeString(ticker, 'askSize'),
+            'vwap': undefined,
+            'open': open,
+            'close': last,
+            'last': last,
+            'previousClose': undefined,
+            'change': undefined,
+            'percentage': undefined,
+            'average': undefined,
+            'baseVolume': baseVolume,
+            'quoteVolume': quoteVolume,
+            'info': ticker,
+        }, market);
+    }
+    async fetchTicker(symbol, params = {}) {
+        /**
+         * @method
+         * @name blofin#fetchTicker
+         * @description fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+         * @see https://blofin.com/docs#get-tickers
+         * @param {string} symbol unified symbol of the market to fetch the ticker for
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+         */
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const request = {
+            'instId': market['id'],
+        };
+        const response = await this.publicGetMarketTickers(this.extend(request, params));
+        const data = this.safeList(response, 'data', []);
+        const first = this.safeValue(data, 0, {});
+        return this.parseTicker(first, market);
+    }
+    async fetchTickers(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name blofin#fetchTickers
+         * @description fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
+         * @see https://blofin.com/docs#get-tickers
+         * @param {string[]} [symbols] unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} a dictionary of [ticker structures]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+         */
+        await this.loadMarkets();
+        symbols = this.marketSymbols(symbols);
+        const response = await this.publicGetMarketTickers(params);
+        const tickers = this.safeList(response, 'data', []);
+        return this.parseTickers(tickers, symbols);
+    }
+    parseTrade(trade, market = undefined) {
+        //
+        // fetch trades
+        //   {
+        //       "tradeId": "3263934920",
+        //       "instId": "LTC-USDT",
+        //       "price": "67.87",
+        //       "size": "1",
+        //       "side": "buy",
+        //       "ts": "1707232020854"
+        //   }
+        // my trades
+        //   {
+        //       "instId": "LTC-USDT",
+        //       "tradeId": "1440847",
+        //       "orderId": "2075705202",
+        //       "fillPrice": "67.850000000000000000",
+        //       "fillSize": "1.000000000000000000",
+        //       "fillPnl": "0.000000000000000000",
+        //       "side": "buy",
+        //       "positionSide": "net",
+        //       "fee": "0.040710000000000000",
+        //       "ts": "1707224678878",
+        //       "brokerId": ""
+        //   }
+        //
+        const id = this.safeString(trade, 'tradeId');
+        const marketId = this.safeString(trade, 'instId');
+        market = this.safeMarket(marketId, market, '-');
+        const symbol = market['symbol'];
+        const timestamp = this.safeInteger(trade, 'ts');
+        const price = this.safeString2(trade, 'price', 'fillPrice');
+        const amount = this.safeString2(trade, 'size', 'fillSize');
+        const side = this.safeString(trade, 'side');
+        const orderId = this.safeString(trade, 'orderId');
+        const feeCost = this.safeString(trade, 'fee');
+        let fee = undefined;
+        if (feeCost !== undefined) {
+            fee = {
+                'cost': feeCost,
+                'currency': market['settle'],
+            };
+        }
+        return this.safeTrade({
+            'info': trade,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'symbol': symbol,
+            'id': id,
+            'order': orderId,
+            'type': undefined,
+            'takerOrMaker': undefined,
+            'side': side,
+            'price': price,
+            'amount': amount,
+            'cost': undefined,
+            'fee': fee,
+        }, market);
+    }
+    async fetchTrades(symbol, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name blofin#fetchTrades
+         * @description get the list of most recent trades for a particular symbol
+         * @see https://blofin.com/docs#get-trades
+         * @param {string} symbol unified symbol of the market to fetch trades for
+         * @param {int} [since] timestamp in ms of the earliest trade to fetch
+         * @param {int} [limit] the maximum amount of trades to fetch
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {boolean} [params.paginate] *only applies to publicGetMarketHistoryTrades* default false, when true will automatically paginate by calling this endpoint multiple times
+         * @returns {Trade[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades}
+         */
+        await this.loadMarkets();
+        let paginate = false;
+        [paginate, params] = this.handleOptionAndParams(params, 'fetchTrades', 'paginate');
+        if (paginate) {
+            return await this.fetchPaginatedCallCursor('fetchTrades', symbol, since, limit, params, 'tradeId', 'after', undefined, 100);
+        }
+        const market = this.market(symbol);
+        const request = {
+            'instId': market['id'],
+        };
+        let response = undefined;
+        if (limit !== undefined) {
+            request['limit'] = limit; // default 100
+        }
+        let method = undefined;
+        [method, params] = this.handleOptionAndParams(params, 'fetchTrades', 'method', 'publicGetMarketTrades');
+        if (method === 'publicGetMarketTrades') {
+            response = await this.publicGetMarketTrades(this.extend(request, params));
+        }
+        const data = this.safeList(response, 'data', []);
+        return this.parseTrades(data, market, since, limit);
+    }
+    parseOHLCV(ohlcv, market = undefined) {
+        //
+        //     [
+        //         "1678928760000", // timestamp
+        //         "24341.4", // open
+        //         "24344", // high
+        //         "24313.2", // low
+        //         "24323", // close
+        //         "628", // contract volume
+        //         "2.5819", // base volume
+        //         "62800", // quote volume
+        //         "0" // candlestick state
+        //     ]
+        //
+        return [
+            this.safeInteger(ohlcv, 0),
+            this.safeNumber(ohlcv, 1),
+            this.safeNumber(ohlcv, 2),
+            this.safeNumber(ohlcv, 3),
+            this.safeNumber(ohlcv, 4),
+            this.safeNumber(ohlcv, 6),
+        ];
+    }
+    async fetchOHLCV(symbol, timeframe = '1m', since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name blofin#fetchOHLCV
+         * @description fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+         * @see https://blofin.com/docs#get-candlesticks
+         * @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 exchange API endpoint
+         * @param {int} [params.until] timestamp in ms of the latest candle to fetch
+         * @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 {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
+         */
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        let paginate = false;
+        [paginate, params] = this.handleOptionAndParams(params, 'fetchOHLCV', 'paginate');
+        if (paginate) {
+            return await this.fetchPaginatedCallDeterministic('fetchOHLCV', symbol, since, limit, timeframe, params, 100);
+        }
+        if (limit === undefined) {
+            limit = 100; // default 100, max 100
+        }
+        const request = {
+            'instId': market['id'],
+            'bar': this.safeString(this.timeframes, timeframe, timeframe),
+            'limit': limit,
+        };
+        const until = this.safeInteger(params, 'until');
+        if (until !== undefined) {
+            request['after'] = until;
+            params = this.omit(params, 'until');
+        }
+        let response = undefined;
+        response = await this.publicGetMarketCandles(this.extend(request, params));
+        const data = this.safeList(response, 'data', []);
+        return this.parseOHLCVs(data, market, timeframe, since, limit);
+    }
+    async fetchFundingRateHistory(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name blofin#fetchFundingRateHistory
+         * @description fetches historical funding rate prices
+         * @see https://blofin.com/docs#get-funding-rate-history
+         * @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://docs.ccxt.com/#/?id=funding-rate-history-structure} to fetch
+         * @param {object} [params] extra parameters specific to the exchange 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://docs.ccxt.com/#/?id=funding-rate-history-structure}
+         */
+        if (symbol === undefined) {
+            throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.ArgumentsRequired(this.id + ' fetchFundingRateHistory() requires a symbol argument');
+        }
+        await this.loadMarkets();
+        let paginate = false;
+        [paginate, params] = this.handleOptionAndParams(params, 'fetchFundingRateHistory', 'paginate');
+        if (paginate) {
+            return await this.fetchPaginatedCallDeterministic('fetchFundingRateHistory', symbol, since, limit, '8h', params);
+        }
+        const market = this.market(symbol);
+        const request = {
+            'instId': market['id'],
+        };
+        if (since !== undefined) {
+            request['before'] = Math.max(since - 1, 0);
+        }
+        if (limit !== undefined) {
+            request['limit'] = limit;
+        }
+        const response = await this.publicGetMarketFundingRateHistory(this.extend(request, params));
+        const rates = [];
+        const data = this.safeList(response, 'data', []);
+        for (let i = 0; i < data.length; i++) {
+            const rate = data[i];
+            const timestamp = this.safeInteger(rate, 'fundingTime');
+            rates.push({
+                'info': rate,
+                'symbol': market['symbol'],
+                'fundingRate': this.safeNumber(rate, 'fundingRate'),
+                'timestamp': timestamp,
+                'datetime': this.iso8601(timestamp),
+            });
+        }
+        const sorted = this.sortBy(rates, 'timestamp');
+        return this.filterBySymbolSinceLimit(sorted, market['symbol'], since, limit);
+    }
+    parseFundingRate(contract, market = undefined) {
+        //
+        //    {
+        //        "fundingRate": "0.00027815",
+        //        "fundingTime": "1634256000000",
+        //        "instId": "BTC-USD-SWAP",
+        //        "instType": "SWAP",
+        //        "nextFundingRate": "0.00017",
+        //        "nextFundingTime": "1634284800000"
+        //    }
+        //
+        // in the response above nextFundingRate is actually two funding rates from now
+        //
+        const nextFundingRateTimestamp = this.safeInteger(contract, 'nextFundingTime');
+        const marketId = this.safeString(contract, 'instId');
+        const symbol = this.safeSymbol(marketId, market);
+        const nextFundingRate = this.safeNumber(contract, 'nextFundingRate');
+        const fundingTime = this.safeInteger(contract, 'fundingTime');
+        // > The current interest is 0.
+        return {
+            'info': contract,
+            'symbol': symbol,
+            'markPrice': undefined,
+            'indexPrice': undefined,
+            'interestRate': this.parseNumber('0'),
+            'estimatedSettlePrice': undefined,
+            'timestamp': undefined,
+            'datetime': undefined,
+            'fundingRate': this.safeNumber(contract, 'fundingRate'),
+            'fundingTimestamp': fundingTime,
+            'fundingDatetime': this.iso8601(fundingTime),
+            'nextFundingRate': nextFundingRate,
+            'nextFundingTimestamp': nextFundingRateTimestamp,
+            'nextFundingDatetime': this.iso8601(nextFundingRateTimestamp),
+            'previousFundingRate': undefined,
+            'previousFundingTimestamp': undefined,
+            'previousFundingDatetime': undefined,
+        };
+    }
+    async fetchFundingRate(symbol, params = {}) {
+        /**
+         * @method
+         * @name blofin#fetchFundingRate
+         * @description fetch the current funding rate
+         * @see https://blofin.com/docs#get-funding-rate
+         * @param {string} symbol unified market symbol
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} a [funding rate structure]{@link https://docs.ccxt.com/#/?id=funding-rate-structure}
+         */
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        if (!market['swap']) {
+            throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.ExchangeError(this.id + ' fetchFundingRate() is only valid for swap markets');
+        }
+        const request = {
+            'instId': market['id'],
+        };
+        const response = await this.publicGetMarketFundingRate(this.extend(request, params));
+        //
+        //    {
+        //        "code": "0",
+        //        "data": [
+        //            {
+        //                "fundingRate": "0.00027815",
+        //                "fundingTime": "1634256000000",
+        //                "instId": "BTC-USD-SWAP",
+        //                "instType": "SWAP",
+        //                "nextFundingRate": "0.00017",
+        //                "nextFundingTime": "1634284800000"
+        //            }
+        //        ],
+        //        "msg": ""
+        //    }
+        //
+        const data = this.safeList(response, 'data', []);
+        const entry = this.safeDict(data, 0, {});
+        return this.parseFundingRate(entry, market);
+    }
+    parseBalanceByType(type, response) {
+        if (type) {
+            return this.parseFundingBalance(response);
+        }
+        else {
+            return this.parseTradingBalance(response);
+        }
+    }
+    parseTradingBalance(response) {
+        //
+        // {
+        //     "code": "0",
+        //     "msg": "success",
+        //     "data": {
+        //         "ts": "1697021343571",
+        //         "totalEquity": "10011254.077985990315787910",
+        //         "isolatedEquity": "861.763132108800000000",
+        //         "details": [
+        //             {
+        //                 "currency": "USDT",
+        //                 "equity": "10014042.988958415234430699548",
+        //                 "balance": "10013119.885958415234430699",
+        //                 "ts": "1697021343571",
+        //                 "isolatedEquity": "862.003200000000000000048",
+        //                 "available": "9996399.4708691159703362725",
+        //                 "availableEquity": "9996399.4708691159703362725",
+        //                 "frozen": "15805.149672632597427761",
+        //                 "orderFrozen": "14920.994472632597427761",
+        //                 "equityUsd": "10011254.077985990315787910",
+        //                 "isolatedUnrealizedPnl": "-22.151999999999999999952",
+        //                 "bonus": "0"
+        //             }
+        //         ]
+        //     }
+        // }
+        //
+        const result = { 'info': response };
+        const data = this.safeDict(response, 'data', {});
+        const timestamp = this.safeInteger(data, 'ts');
+        const details = this.safeList(data, 'details', []);
+        for (let i = 0; i < details.length; i++) {
+            const balance = details[i];
+            const currencyId = this.safeString(balance, 'currency');
+            const code = this.safeCurrencyCode(currencyId);
+            const account = this.account();
+            // it may be incorrect to use total, free and used for swap accounts
+            const eq = this.safeString(balance, 'equity');
+            const availEq = this.safeString(balance, 'available');
+            if ((eq === undefined) || (availEq === undefined)) {
+                account['free'] = this.safeString(balance, 'availableEquity');
+                account['used'] = this.safeString(balance, 'frozen');
+            }
+            else {
+                account['total'] = eq;
+                account['free'] = availEq;
+            }
+            result[code] = account;
+        }
+        result['timestamp'] = timestamp;
+        result['datetime'] = this.iso8601(timestamp);
+        return this.safeBalance(result);
+    }
+    parseFundingBalance(response) {
+        //
+        //  {
+        //      "code": "0",
+        //      "msg": "success",
+        //      "data": [
+        //          {
+        //              "currency": "USDT",
+        //              "balance": "10012514.919418081548717298",
+        //              "available": "9872132.414278782284622898",
+        //              "frozen": "138556.471805965930761067",
+        //              "bonus": "0"
+        //          }
+        //      ]
+        //  }
+        //
+        const result = { 'info': response };
+        const data = this.safeList(response, 'data', []);
+        for (let i = 0; i < data.length; i++) {
+            const balance = data[i];
+            const currencyId = this.safeString(balance, 'currency');
+            const code = this.safeCurrencyCode(currencyId);
+            const account = this.account();
+            // it may be incorrect to use total, free and used for swap accounts
+            account['total'] = this.safeString(balance, 'balance');
+            account['free'] = this.safeString(balance, 'available');
+            account['used'] = this.safeString(balance, 'frozen');
+            result[code] = account;
+        }
+        return this.safeBalance(result);
+    }
+    parseTradingFee(fee, market = undefined) {
+        return {
+            'info': fee,
+            'symbol': this.safeSymbol(undefined, market),
+            // blofin returns the fees as negative values opposed to other exchanges, so the sign needs to be flipped
+            'maker': this.parseNumber(_base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise */ .O.stringNeg(this.safeString2(fee, 'maker', 'makerU'))),
+            'taker': this.parseNumber(_base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise */ .O.stringNeg(this.safeString2(fee, 'taker', 'takerU'))),
+        };
+    }
+    async fetchBalance(params = {}) {
+        /**
+         * @method
+         * @name blofin#fetchBalance
+         * @description query for balance and get the amount of funds available for trading or funds locked in orders
+         * @see https://blofin.com/docs#get-balance
+         * @see https://blofin.com/docs#get-futures-account-balance
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {string} [params.accountType] the type of account to fetch the balance for, either 'funding' or 'futures'  or 'copy_trading' or 'earn'
+         * @returns {object} a [balance structure]{@link https://docs.ccxt.com/#/?id=balance-structure}
+         */
+        await this.loadMarkets();
+        const accountType = this.safeString2(params, 'accountType', 'type');
+        params = this.omit(params, ['accountType', 'type']);
+        const request = {};
+        let response = undefined;
+        if (accountType !== undefined) {
+            const parsedAccountType = this.safeString(this.options, 'accountsByType', accountType);
+            request['accountType'] = parsedAccountType;
+            response = await this.privateGetAssetBalances(this.extend(request, params));
+        }
+        else {
+            response = await this.privateGetAccountBalance(this.extend(request, params));
+        }
+        return this.parseBalanceByType(accountType, response);
+    }
+    createOrderRequest(symbol, type, side, amount, price = undefined, params = {}) {
+        const market = this.market(symbol);
+        const request = {
+            'instId': market['id'],
+            'side': side,
+            'orderType': type,
+            'size': this.amountToPrecision(symbol, amount),
+            'brokerId': this.safeString(this.options, 'brokerId', 'ec6dd3a7dd982d0b'),
+        };
+        let marginMode = undefined;
+        [marginMode, params] = this.handleMarginModeAndParams('createOrder', params, 'cross');
+        request['marginMode'] = marginMode;
+        const timeInForce = this.safeString(params, 'timeInForce', 'GTC');
+        const isMarketOrder = type === 'market';
+        params = this.omit(params, ['timeInForce']);
+        const ioc = (timeInForce === 'IOC') || (type === 'ioc');
+        const marketIOC = (isMarketOrder && ioc);
+        if (isMarketOrder || marketIOC) {
+            request['orderType'] = 'market';
+        }
+        else {
+            request['price'] = this.priceToPrecision(symbol, price);
+        }
+        let postOnly = false;
+        [postOnly, params] = this.handlePostOnly(isMarketOrder, type === 'post_only', params);
+        if (postOnly) {
+            request['type'] = 'post_only';
+        }
+        const stopLoss = this.safeValue(params, 'stopLoss');
+        const takeProfit = this.safeValue(params, 'takeProfit');
+        params = this.omit(params, ['stopLoss', 'takeProfit']);
+        const isStopLoss = stopLoss !== undefined;
+        const isTakeProfit = takeProfit !== undefined;
+        if (isStopLoss || isTakeProfit) {
+            if (isStopLoss) {
+                const slTriggerPrice = this.safeString2(stopLoss, 'triggerPrice', 'stopPrice');
+                request['slTriggerPrice'] = this.priceToPrecision(symbol, slTriggerPrice);
+                const slOrderPrice = this.safeString(stopLoss, 'price', '-1');
+                request['slOrderPrice'] = this.priceToPrecision(symbol, slOrderPrice);
+            }
+            if (isTakeProfit) {
+                const tpTriggerPrice = this.safeString2(takeProfit, 'triggerPrice', 'stopPrice');
+                request['tpTriggerPrice'] = this.priceToPrecision(symbol, tpTriggerPrice);
+                const tpPrice = this.safeString(takeProfit, 'price', '-1');
+                request['tpOrderPrice'] = this.priceToPrecision(symbol, tpPrice);
+            }
+        }
+        return this.extend(request, params);
+    }
+    parseOrderStatus(status) {
+        const statuses = {
+            'canceled': 'canceled',
+            'order_failed': 'canceled',
+            'live': 'open',
+            'partially_filled': 'open',
+            'filled': 'closed',
+            'effective': 'closed',
+        };
+        return this.safeString(statuses, status, status);
+    }
+    parseOrder(order, market = undefined) {
+        //
+        // {
+        //     "orderId": "2075628533",
+        //     "clientOrderId": "",
+        //     "instId": "LTC-USDT",
+        //     "marginMode": "cross",
+        //     "positionSide": "net",
+        //     "side": "buy",
+        //     "orderType": "market",
+        //     "price": "0.000000000000000000",
+        //     "size": "1.000000000000000000",
+        //     "reduceOnly": "true",
+        //     "leverage": "3",
+        //     "state": "filled",
+        //     "filledSize": "1.000000000000000000",
+        //     "pnl": "-0.050000000000000000",
+        //     "averagePrice": "68.110000000000000000",
+        //     "fee": "0.040866000000000000",
+        //     "createTime": "1706891359010",
+        //     "updateTime": "1706891359098",
+        //     "orderCategory": "normal",
+        //     "tpTriggerPrice": null,
+        //     "tpOrderPrice": null,
+        //     "slTriggerPrice": null,
+        //     "slOrderPrice": null,
+        //     "cancelSource": "not_canceled",
+        //     "cancelSourceReason": null,
+        //     "brokerId": "ec6dd3a7dd982d0b"
+        // }
+        //
+        const id = this.safeString2(order, 'tpslId', 'orderId');
+        const timestamp = this.safeInteger(order, 'createTime');
+        const lastUpdateTimestamp = this.safeInteger(order, 'updateTime');
+        const lastTradeTimestamp = this.safeInteger(order, 'fillTime');
+        const side = this.safeString(order, 'side');
+        let type = this.safeString(order, 'orderType');
+        let postOnly = undefined;
+        let timeInForce = undefined;
+        if (type === 'post_only') {
+            postOnly = true;
+            type = 'limit';
+        }
+        else if (type === 'fok') {
+            timeInForce = 'FOK';
+            type = 'limit';
+        }
+        else if (type === 'ioc') {
+            timeInForce = 'IOC';
+            type = 'limit';
+        }
+        const marketId = this.safeString(order, 'instId');
+        market = this.safeMarket(marketId, market);
+        const symbol = this.safeSymbol(marketId, market, '-');
+        const filled = this.safeString(order, 'filledSize');
+        const price = this.safeString2(order, 'px', 'price');
+        const average = this.safeString(order, 'averagePrice');
+        const status = this.parseOrderStatus(this.safeString(order, 'state'));
+        const feeCostString = this.safeString(order, 'fee');
+        const amount = this.safeString(order, 'size');
+        const leverage = this.safeString(order, 'leverage', '1');
+        const contractSize = this.safeString(market, 'contractSize');
+        const baseAmount = _base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise */ .O.stringMul(contractSize, filled);
+        let cost = undefined;
+        if (average !== undefined) {
+            cost = _base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise */ .O.stringMul(average, baseAmount);
+            cost = _base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise */ .O.stringDiv(cost, leverage);
+        }
+        // spot market buy: "sz" can refer either to base currency units or to quote currency units
+        let fee = undefined;
+        if (feeCostString !== undefined) {
+            const feeCostSigned = _base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise */ .O.stringAbs(feeCostString);
+            const feeCurrencyId = this.safeString(order, 'feeCcy', 'USDT');
+            const feeCurrencyCode = this.safeCurrencyCode(feeCurrencyId);
+            fee = {
+                'cost': this.parseNumber(feeCostSigned),
+                'currency': feeCurrencyCode,
+            };
+        }
+        let clientOrderId = this.safeString(order, 'clientOrderId');
+        if ((clientOrderId !== undefined) && (clientOrderId.length < 1)) {
+            clientOrderId = undefined; // fix empty clientOrderId string
+        }
+        const stopLossTriggerPrice = this.safeNumber(order, 'slTriggerPrice');
+        const stopLossPrice = this.safeNumber(order, 'slOrderPrice');
+        const takeProfitTriggerPrice = this.safeNumber(order, 'tpTriggerPrice');
+        const takeProfitPrice = this.safeNumber(order, 'tpOrderPrice');
+        const reduceOnlyRaw = this.safeString(order, 'reduceOnly');
+        const reduceOnly = (reduceOnlyRaw === 'true');
+        return this.safeOrder({
+            'info': order,
+            'id': id,
+            'clientOrderId': clientOrderId,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'lastTradeTimestamp': lastTradeTimestamp,
+            'lastUpdateTimestamp': lastUpdateTimestamp,
+            'symbol': symbol,
+            'type': type,
+            'timeInForce': timeInForce,
+            'postOnly': postOnly,
+            'side': side,
+            'price': price,
+            'stopLossTriggerPrice': stopLossTriggerPrice,
+            'takeProfitTriggerPrice': takeProfitTriggerPrice,
+            'stopLossPrice': stopLossPrice,
+            'takeProfitPrice': takeProfitPrice,
+            'average': average,
+            'cost': cost,
+            'amount': amount,
+            'filled': filled,
+            'remaining': undefined,
+            'status': status,
+            'fee': fee,
+            'trades': undefined,
+            'reduceOnly': reduceOnly,
+        }, market);
+    }
+    async createOrder(symbol, type, side, amount, price = undefined, params = {}) {
+        /**
+         * @method
+         * @name blofin#createOrder
+         * @description create a trade order
+         * @see https://blofin.com/docs#place-order
+         * @see https://blofin.com/docs#place-tpsl-order
+         * @param {string} symbol unified symbol of the market to create an order in
+         * @param {string} type 'market' or 'limit' or 'post_only' or 'ioc' or 'fok'
+         * @param {string} side 'buy' or 'sell'
+         * @param {float} amount how much of currency you want to trade in units of base currency
+         * @param {float} [price] the price at which the order is to be fullfilled, in units of the quote currency, ignored in market orders
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {bool} [params.reduceOnly] a mark to reduce the position size for margin, swap and future orders
+         * @param {bool} [params.postOnly] true to place a post only order
+         * @param {string} [params.marginMode] 'cross' or 'isolated', default is 'cross'
+         * @param {float} [params.stopLossPrice] stop loss trigger price (will use privatePostTradeOrderTpsl)
+         * @param {float} [params.takeProfitPrice] take profit trigger price (will use privatePostTradeOrderTpsl)
+         * @param {string} [param.positionSide] *stopLossPrice/takeProfitPrice orders only* 'long' or 'short' or 'net' default is 'net'
+         * @param {string} [params.clientOrderId] a unique id for the order
+         * @param {object} [params.takeProfit] *takeProfit object in params* containing the triggerPrice at which the attached take profit order will be triggered
+         * @param {float} [params.takeProfit.triggerPrice] take profit trigger price
+         * @param {float} [params.takeProfit.price] take profit order price (if not provided the order will be a market order)
+         * @param {object} [params.stopLoss] *stopLoss object in params* containing the triggerPrice at which the attached stop loss order will be triggered
+         * @param {float} [params.stopLoss.triggerPrice] stop loss trigger price
+         * @param {float} [params.stopLoss.price] stop loss order price (if not provided the order will be a market order)
+         * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const tpsl = this.safeBool(params, 'tpsl', false);
+        params = this.omit(params, 'tpsl');
+        let method = undefined;
+        [method, params] = this.handleOptionAndParams(params, 'createOrder', 'method', 'privatePostTradeOrder');
+        const isStopLossPriceDefined = this.safeString(params, 'stopLossPrice') !== undefined;
+        const isTakeProfitPriceDefined = this.safeString(params, 'takeProfitPrice') !== undefined;
+        const isType2Order = (isStopLossPriceDefined || isTakeProfitPriceDefined);
+        let response = undefined;
+        if (tpsl || (method === 'privatePostTradeOrderTpsl') || isType2Order) {
+            const tpslRequest = this.createTpslOrderRequest(symbol, type, side, amount, price, params);
+            response = await this.privatePostTradeOrderTpsl(tpslRequest);
+        }
+        else {
+            const request = this.createOrderRequest(symbol, type, side, amount, price, params);
+            response = await this.privatePostTradeOrder(request);
+        }
+        const data = this.safeList(response, 'data', []);
+        const first = this.safeDict(data, 0);
+        const order = this.parseOrder(first, market);
+        order['type'] = type;
+        order['side'] = side;
+        return order;
+    }
+    createTpslOrderRequest(symbol, type, side, amount = undefined, price = undefined, params = {}) {
+        const market = this.market(symbol);
+        const positionSide = this.safeString(params, 'positionSide', 'net');
+        const request = {
+            'instId': market['id'],
+            'side': side,
+            'positionSide': positionSide,
+            'brokerId': this.safeString(this.options, 'brokerId', 'ec6dd3a7dd982d0b'),
+        };
+        if (amount !== undefined) {
+            request['size'] = this.amountToPrecision(symbol, amount);
+        }
+        const marginMode = this.safeString(params, 'marginMode', 'cross'); // cross or isolated
+        if (marginMode !== 'cross' && marginMode !== 'isolated') {
+            throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.BadRequest(this.id + ' createTpslOrder() requires a marginMode parameter that must be either cross or isolated');
+        }
+        const stopLossPrice = this.safeString(params, 'stopLossPrice');
+        const takeProfitPrice = this.safeString(params, 'takeProfitPrice');
+        if (stopLossPrice !== undefined) {
+            request['slTriggerPrice'] = this.priceToPrecision(symbol, stopLossPrice);
+            if (type === 'market') {
+                request['slOrderPrice'] = '-1';
+            }
+            else {
+                request['slOrderPrice'] = this.priceToPrecision(symbol, price);
+            }
+        }
+        else if (takeProfitPrice !== undefined) {
+            request['tpTriggerPrice'] = this.priceToPrecision(symbol, takeProfitPrice);
+            if (type === 'market') {
+                request['tpOrderPrice'] = '-1';
+            }
+            else {
+                request['tpOrderPrice'] = this.priceToPrecision(symbol, price);
+            }
+        }
+        request['marginMode'] = marginMode;
+        params = this.omit(params, ['stopLossPrice', 'takeProfitPrice']);
+        return this.extend(request, params);
+    }
+    async cancelOrder(id, symbol = undefined, params = {}) {
+        /**
+         * @method
+         * @name blofin#cancelOrder
+         * @description cancels an open order
+         * @see https://blofin.com/docs#cancel-order
+         * @see https://blofin.com/docs#cancel-tpsl-order
+         * @param {string} id order id
+         * @param {string} symbol unified symbol of the market the order was made in
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        if (symbol === undefined) {
+            throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.ArgumentsRequired(this.id + ' cancelOrder() requires a symbol argument');
+        }
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const request = {
+            'instId': market['id'],
+        };
+        const clientOrderId = this.safeString(params, 'clientOrderId');
+        if (clientOrderId !== undefined) {
+            request['clientOrderId'] = clientOrderId;
+        }
+        else {
+            request['orderId'] = id;
+        }
+        const query = this.omit(params, ['orderId', 'clientOrderId']);
+        const response = await this.privatePostTradeCancelOrder(this.extend(request, query));
+        const data = this.safeList(response, 'data', []);
+        const order = this.safeDict(data, 0);
+        return this.parseOrder(order, market);
+    }
+    async createOrders(orders, params = {}) {
+        /**
+         * @method
+         * @name blofin#createOrders
+         * @description create a list of trade orders
+         * @see https://blofin.com/docs#place-multiple-orders
+         * @param {Array} orders list of orders to create, each object should contain the parameters required by createOrder, namely symbol, type, side, amount, price and params
+         * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        await this.loadMarkets();
+        const ordersRequests = [];
+        for (let i = 0; i < orders.length; i++) {
+            const rawOrder = orders[i];
+            const marketId = this.safeString(rawOrder, 'symbol');
+            const type = this.safeString(rawOrder, 'type');
+            const side = this.safeString(rawOrder, 'side');
+            const amount = this.safeValue(rawOrder, 'amount');
+            const price = this.safeValue(rawOrder, 'price');
+            const orderParams = this.safeValue(rawOrder, 'params', {});
+            const extendedParams = this.extend(orderParams, params); // the request does not accept extra params since it's a list, so we're extending each order with the common params
+            const orderRequest = this.createOrderRequest(marketId, type, side, amount, price, extendedParams);
+            ordersRequests.push(orderRequest);
+        }
+        const response = await this.privatePostTradeBatchOrders(ordersRequests);
+        const data = this.safeList(response, 'data', []);
+        return this.parseOrders(data);
+    }
+    async fetchOpenOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name blofin#fetchOpenOrders
+         * @description Fetch orders that are still open
+         * @see https://blofin.com/docs#get-active-orders
+         * @see https://blofin.com/docs#get-active-tpsl-orders
+         * @param {string} symbol unified market symbol
+         * @param {int} [since] the earliest time in ms to fetch open orders for
+         * @param {int} [limit] the maximum number of  open orders structures to retrieve
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {bool} [params.stop] True if fetching trigger or conditional orders
+         * @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 {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        await this.loadMarkets();
+        let paginate = false;
+        [paginate, params] = this.handleOptionAndParams(params, 'fetchOpenOrders', 'paginate');
+        if (paginate) {
+            return await this.fetchPaginatedCallDynamic('fetchOpenOrders', symbol, since, limit, params);
+        }
+        const request = {};
+        let market = undefined;
+        if (symbol !== undefined) {
+            market = this.market(symbol);
+            request['instId'] = market['id'];
+        }
+        if (limit !== undefined) {
+            request['limit'] = limit; // default 100, max 100
+        }
+        const isStop = this.safeValueN(params, ['stop', 'trigger', 'tpsl', 'TPSL'], false);
+        let method = undefined;
+        [method, params] = this.handleOptionAndParams(params, 'fetchOpenOrders', 'method', 'privateGetTradeOrdersPending');
+        const query = this.omit(params, ['method', 'stop', 'trigger', 'tpsl', 'TPSL']);
+        let response = undefined;
+        if (isStop || (method === 'privateGetTradeOrdersTpslPending')) {
+            response = await this.privateGetTradeOrdersTpslPending(this.extend(request, query));
+        }
+        else {
+            response = await this.privateGetTradeOrdersPending(this.extend(request, query));
+        }
+        const data = this.safeList(response, 'data', []);
+        return this.parseOrders(data, market, since, limit);
+    }
+    async fetchMyTrades(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name blofin#fetchMyTrades
+         * @description fetch all trades made by the user
+         * @see https://blofin.com/docs#get-trade-history
+         * @param {string} symbol unified market symbol
+         * @param {int} [since] the earliest time in ms to fetch trades for
+         * @param {int} [limit] the maximum number of trades structures to retrieve
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {int} [params.until] Timestamp in ms of the latest time to retrieve trades for
+         * @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 {Trade[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure}
+         */
+        await this.loadMarkets();
+        let paginate = false;
+        [paginate, params] = this.handleOptionAndParams(params, 'fetchMyTrades', 'paginate');
+        if (paginate) {
+            return await this.fetchPaginatedCallDynamic('fetchMyTrades', symbol, since, limit, params);
+        }
+        let request = {};
+        let market = undefined;
+        if (symbol !== undefined) {
+            market = this.market(symbol);
+            request['instId'] = market['id'];
+        }
+        [request, params] = this.handleUntilOption('end', request, params);
+        if (limit !== undefined) {
+            request['limit'] = limit; // default 100, max 100
+        }
+        const response = await this.privateGetTradeFillsHistory(this.extend(request, params));
+        const data = this.safeList(response, 'data', []);
+        return this.parseTrades(data, market, since, limit);
+    }
+    async fetchDeposits(code = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name blofin#fetchDeposits
+         * @description fetch all deposits made to an account
+         * @see https://blofin.com/docs#get-deposite-history
+         * @param {string} code unified currency code
+         * @param {int} [since] the earliest time in ms to fetch deposits for
+         * @param {int} [limit] the maximum number of deposits structures to retrieve
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {int} [params.until] the latest time in ms to fetch entries for
+         * @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 [transaction structures]{@link https://docs.ccxt.com/#/?id=transaction-structure}
+         */
+        await this.loadMarkets();
+        let paginate = false;
+        [paginate, params] = this.handleOptionAndParams(params, 'fetchDeposits', 'paginate');
+        if (paginate) {
+            return await this.fetchPaginatedCallDynamic('fetchDeposits', code, since, limit, params);
+        }
+        let request = {};
+        let currency = undefined;
+        if (code !== undefined) {
+            currency = this.currency(code);
+            request['currency'] = currency['id'];
+        }
+        if (since !== undefined) {
+            request['before'] = Math.max(since - 1, 0);
+        }
+        if (limit !== undefined) {
+            request['limit'] = limit; // default 100, max 100
+        }
+        [request, params] = this.handleUntilOption('after', request, params);
+        const response = await this.privateGetAssetDepositHistory(this.extend(request, params));
+        const data = this.safeList(response, 'data', []);
+        return this.parseTransactions(data, currency, since, limit, params);
+    }
+    async fetchWithdrawals(code = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name blofin#fetchWithdrawals
+         * @description fetch all withdrawals made from an account
+         * @see https://blofin.com/docs#get-withdraw-history
+         * @param {string} code unified currency code
+         * @param {int} [since] the earliest time in ms to fetch withdrawals for
+         * @param {int} [limit] the maximum number of withdrawals structures to retrieve
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {int} [params.until] the latest time in ms to fetch entries for
+         * @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 [transaction structures]{@link https://docs.ccxt.com/#/?id=transaction-structure}
+         */
+        await this.loadMarkets();
+        let paginate = false;
+        [paginate, params] = this.handleOptionAndParams(params, 'fetchWithdrawals', 'paginate');
+        if (paginate) {
+            return await this.fetchPaginatedCallDynamic('fetchWithdrawals', code, since, limit, params);
+        }
+        let request = {};
+        let currency = undefined;
+        if (code !== undefined) {
+            currency = this.currency(code);
+            request['currency'] = currency['id'];
+        }
+        if (since !== undefined) {
+            request['before'] = Math.max(since - 1, 0);
+        }
+        if (limit !== undefined) {
+            request['limit'] = limit; // default 100, max 100
+        }
+        [request, params] = this.handleUntilOption('after', request, params);
+        const response = await this.privateGetAssetWithdrawalHistory(this.extend(request, params));
+        const data = this.safeList(response, 'data', []);
+        return this.parseTransactions(data, currency, since, limit, params);
+    }
+    async fetchLedger(code = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name blofin#fetchLedger
+         * @description fetch the history of changes, actions done by the user or operations that altered balance of the user
+         * @see https://blofin.com/docs#get-funds-transfer-history
+         * @param {string} code unified currency code, default is undefined
+         * @param {int} [since] timestamp in ms of the earliest ledger entry, default is undefined
+         * @param {int} [limit] max number of ledger entrys to return, default is undefined
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {string} [params.marginMode] 'cross' or 'isolated'
+         * @param {int} [params.until] the latest time in ms to fetch entries for
+         * @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 [ledger structure]{@link https://docs.ccxt.com/#/?id=ledger-structure}
+         */
+        await this.loadMarkets();
+        let paginate = false;
+        [paginate, params] = this.handleOptionAndParams(params, 'fetchLedger', 'paginate');
+        if (paginate) {
+            return await this.fetchPaginatedCallDynamic('fetchLedger', code, since, limit, params);
+        }
+        let request = {};
+        if (limit !== undefined) {
+            request['limit'] = limit;
+        }
+        let currency = undefined;
+        if (code !== undefined) {
+            currency = this.currency(code);
+            request['currency'] = currency['id'];
+        }
+        [request, params] = this.handleUntilOption('end', request, params);
+        let response = undefined;
+        response = await this.privateGetAssetBills(this.extend(request, params));
+        const data = this.safeList(response, 'data', []);
+        return this.parseLedger(data, currency, since, limit);
+    }
+    parseTransaction(transaction, currency = undefined) {
+        //
+        //
+        // fetchDeposits
+        //
+        //     {
+        //         "currency": "USDT",
+        //         "chain": "TRC20",
+        //         "address": "TGfJLtnsh3B9EqekFEBZ1nR14QanBUf5Bi",
+        //         "txId": "892f4e0c32268b29b2e541ef30d32a30bbf10f902adcc4b1428319ed7c3758fd",
+        //         "type": "0",
+        //         "amount": "86.975843",
+        //         "state": "1",
+        //         "ts": "1703163304153",
+        //         "tag": null,
+        //         "confirm": "16",
+        //         "depositId": "36c8e2a7ea184a219de72215a696acaf"
+        //     }
+        // fetchWithdrawals
+        //    {
+        //       "currency": "USDT",
+        //        "chain": "TRC20",
+        //        "address": "TYgB3sVXHPEDQUu288EG1uMFh9Pk2swLgW",
+        //        "txId": "1fd5ac52df414d7ea66194cadd9a5b4d2422c2b9720037f66d98207f9858fd96",
+        //        "type": "0",
+        //        "amount": "9",
+        //        "fee": "1",
+        //        "feeCurrency": "USDT",
+        //        "state": "3",
+        //        "clientId": null,
+        //        "ts": "1707217439351",
+        //        "tag": null,
+        //        "memo": null,
+        //        "withdrawId": "e0768698cfdf4aee8e54654c3775914b"
+        //    }
+        //
+        let type = undefined;
+        let id = undefined;
+        const withdrawalId = this.safeString(transaction, 'withdrawId');
+        const depositId = this.safeString(transaction, 'depositId');
+        const addressTo = this.safeString(transaction, 'address');
+        const address = addressTo;
+        const tagTo = this.safeString(transaction, 'tag');
+        if (withdrawalId !== undefined) {
+            type = 'withdrawal';
+            id = withdrawalId;
+        }
+        else {
+            id = depositId;
+            type = 'deposit';
+        }
+        const currencyId = this.safeString(transaction, 'currency');
+        const code = this.safeCurrencyCode(currencyId);
+        const amount = this.safeNumber(transaction, 'amount');
+        const status = this.parseTransactionStatus(this.safeString(transaction, 'state'));
+        const txid = this.safeString(transaction, 'txId');
+        const timestamp = this.safeInteger(transaction, 'ts');
+        const feeCurrencyId = this.safeString(transaction, 'feeCurrency');
+        const feeCode = this.safeCurrencyCode(feeCurrencyId);
+        const feeCost = this.safeNumber(transaction, 'fee');
+        return {
+            'info': transaction,
+            'id': id,
+            'currency': code,
+            'amount': amount,
+            'network': undefined,
+            'addressFrom': undefined,
+            'addressTo': addressTo,
+            'address': address,
+            'tagFrom': undefined,
+            'tagTo': tagTo,
+            'tag': tagTo,
+            'status': status,
+            'type': type,
+            'updated': undefined,
+            'txid': txid,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'internal': undefined,
+            'comment': undefined,
+            'fee': {
+                'currency': feeCode,
+                'cost': feeCost,
+            },
+        };
+    }
+    parseTransactionStatus(status) {
+        const statuses = {
+            '0': 'pending',
+            '1': 'ok',
+            '2': 'failed',
+            '3': 'pending',
+        };
+        return this.safeString(statuses, status, status);
+    }
+    parseLedgerEntryType(type) {
+        const types = {
+            '1': 'transfer',
+            '2': 'trade',
+            '3': 'trade',
+            '4': 'rebate',
+            '5': 'trade',
+            '6': 'transfer',
+            '7': 'trade',
+            '8': 'fee',
+            '9': 'trade',
+            '10': 'trade',
+            '11': 'trade', // system token conversion
+        };
+        return this.safeString(types, type, type);
+    }
+    parseLedgerEntry(item, currency = undefined) {
+        const id = this.safeString(item, 'transferId');
+        const referenceId = this.safeString(item, 'clientId');
+        const fromAccount = this.safeString(item, 'fromAccount');
+        const toAccount = this.safeString(item, 'toAccount');
+        const type = this.parseLedgerEntryType(this.safeString(item, 'type'));
+        const code = this.safeCurrencyCode(this.safeString(item, 'currency'), currency);
+        const amountString = this.safeString(item, 'amount');
+        const amount = this.parseNumber(amountString);
+        const timestamp = this.safeInteger(item, 'ts');
+        const status = 'ok';
+        return {
+            'id': id,
+            'info': item,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'fromAccount': fromAccount,
+            'toAccount': toAccount,
+            'type': type,
+            'currency': code,
+            'amount': amount,
+            'clientId': referenceId,
+            'status': status,
+        };
+    }
+    parseIds(ids) {
+        /**
+         * @ignore
+         * @method
+         * @name blofin#parseIds
+         * @param {string[]|string} ids order ids
+         * @returns {string[]} list of order ids
+         */
+        if (typeof ids === 'string') {
+            return ids.split(',');
+        }
+        else {
+            return ids;
+        }
+    }
+    async cancelOrders(ids, symbol = undefined, params = {}) {
+        /**
+         * @method
+         * @name blofin#cancelOrders
+         * @description cancel multiple orders
+         * @see https://blofin.com/docs#cancel-multiple-orders
+         * @param {string[]} ids order ids
+         * @param {string} symbol unified market symbol
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {boolean} [params.trigger] whether the order is a stop/trigger order
+         * @returns {object} an list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        // TODO : the original endpoint signature differs, according to that you can skip individual symbol and assign ids in batch. At this moment, `params` is not being used too.
+        if (symbol === undefined) {
+            throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.ArgumentsRequired(this.id + ' cancelOrders() requires a symbol argument');
+        }
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const request = [];
+        const options = this.safeValue(this.options, 'cancelOrders', {});
+        const defaultMethod = this.safeString(options, 'method', 'privatePostTradeCancelBatchOrders');
+        let method = this.safeString(params, 'method', defaultMethod);
+        const clientOrderIds = this.parseIds(this.safeValue(params, 'clientOrderId'));
+        const tpslIds = this.parseIds(this.safeValue(params, 'tpslId'));
+        const stop = this.safeBoolN(params, ['stop', 'trigger', 'tpsl']);
+        if (stop) {
+            method = 'privatePostTradeCancelTpsl';
+        }
+        if (clientOrderIds === undefined) {
+            ids = this.parseIds(ids);
+            if (tpslIds !== undefined) {
+                for (let i = 0; i < tpslIds.length; i++) {
+                    request.push({
+                        'tpslId': tpslIds[i],
+                        'instId': market['id'],
+                    });
+                }
+            }
+            for (let i = 0; i < ids.length; i++) {
+                if (stop) {
+                    request.push({
+                        'tpslId': ids[i],
+                        'instId': market['id'],
+                    });
+                }
+                else {
+                    request.push({
+                        'orderId': ids[i],
+                        'instId': market['id'],
+                    });
+                }
+            }
+        }
+        else {
+            for (let i = 0; i < clientOrderIds.length; i++) {
+                request.push({
+                    'instId': market['id'],
+                    'clientOrderId': clientOrderIds[i],
+                });
+            }
+        }
+        let response = undefined;
+        if (method === 'privatePostTradeCancelTpsl') {
+            response = await this.privatePostTradeCancelTpsl(request); // * dont extend with params, otherwise ARRAY will be turned into OBJECT
+        }
+        else {
+            response = await this.privatePostTradeCancelBatchOrders(request); // * dont extend with params, otherwise ARRAY will be turned into OBJECT
+        }
+        const ordersData = this.safeList(response, 'data', []);
+        return this.parseOrders(ordersData, market, undefined, undefined, params);
+    }
+    async transfer(code, amount, fromAccount, toAccount, params = {}) {
+        /**
+         * @method
+         * @name blofin#transfer
+         * @description transfer currency internally between wallets on the same account
+         * @see https://blofin.com/docs#funds-transfer
+         * @param {string} code unified currency code
+         * @param {float} amount amount to transfer
+         * @param {string} fromAccount account to transfer from (funding, swap, copy_trading, earn)
+         * @param {string} toAccount account to transfer to (funding, swap, copy_trading, earn)
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} a [transfer structure]{@link https://docs.ccxt.com/#/?id=transfer-structure}
+         */
+        await this.loadMarkets();
+        const currency = this.currency(code);
+        const accountsByType = this.safeValue(this.options, 'accountsByType', {});
+        const fromId = this.safeString(accountsByType, fromAccount, fromAccount);
+        const toId = this.safeString(accountsByType, toAccount, toAccount);
+        const request = {
+            'currency': currency['id'],
+            'amount': this.currencyToPrecision(code, amount),
+            'fromAccount': fromId,
+            'toAccount': toId,
+        };
+        const response = await this.privatePostAssetTransfer(this.extend(request, params));
+        const data = this.safeDict(response, 'data', {});
+        return this.parseTransfer(data, currency);
+    }
+    parseTransfer(transfer, currency = undefined) {
+        const id = this.safeString(transfer, 'transferId');
+        return {
+            'info': transfer,
+            'id': id,
+            'timestamp': undefined,
+            'datetime': undefined,
+            'currency': undefined,
+            'amount': undefined,
+            'fromAccount': undefined,
+            'toAccount': undefined,
+            'status': undefined,
+        };
+    }
+    async fetchPosition(symbol, params = {}) {
+        /**
+         * @method
+         * @name blofin#fetchPosition
+         * @description fetch data on a single open contract trade position
+         * @see https://blofin.com/docs#get-positions
+         * @param {string} symbol unified market symbol of the market the position is held in, default is undefined
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {string} [params.instType] MARGIN, SWAP, FUTURES, OPTION
+         * @returns {object} a [position structure]{@link https://docs.ccxt.com/#/?id=position-structure}
+         */
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const request = {
+            'instId': market['id'],
+        };
+        const response = await this.privateGetAccountPositions(this.extend(request, params));
+        const data = this.safeList(response, 'data', []);
+        const position = this.safeDict(data, 0);
+        if (position === undefined) {
+            return undefined;
+        }
+        return this.parsePosition(position, market);
+    }
+    async fetchPositions(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name blofin#fetchPosition
+         * @description fetch data on a single open contract trade position
+         * @see https://blofin.com/docs#get-positions
+         * @param {string[]} [symbols] list of unified market symbols
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {string} [params.instType] MARGIN, SWAP, FUTURES, OPTION
+         * @returns {object} a [position structure]{@link https://docs.ccxt.com/#/?id=position-structure}
+         */
+        await this.loadMarkets();
+        symbols = this.marketSymbols(symbols);
+        const response = await this.privateGetAccountPositions(params);
+        const data = this.safeList(response, 'data', []);
+        const result = this.parsePositions(data);
+        return this.filterByArrayPositions(result, 'symbol', symbols, false);
+    }
+    parsePosition(position, market = undefined) {
+        const marketId = this.safeString(position, 'instId');
+        market = this.safeMarket(marketId, market);
+        const symbol = market['symbol'];
+        const pos = this.safeString(position, 'positions');
+        const contractsAbs = _base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise */ .O.stringAbs(pos);
+        let side = this.safeString(position, 'positionSide');
+        const hedged = side !== 'net';
+        const contracts = this.parseNumber(contractsAbs);
+        if (pos !== undefined) {
+            if (side === 'net') {
+                if (_base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise */ .O.stringGt(pos, '0')) {
+                    side = 'long';
+                }
+                else if (_base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise */ .O.stringLt(pos, '0')) {
+                    side = 'short';
+                }
+                else {
+                    side = undefined;
+                }
+            }
+        }
+        const contractSize = this.safeNumber(market, 'contractSize');
+        const contractSizeString = this.numberToString(contractSize);
+        const markPriceString = this.safeString(position, 'markPrice');
+        let notionalString = this.safeString(position, 'notionalUsd');
+        if (market['inverse']) {
+            notionalString = _base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise */ .O.stringDiv(_base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise */ .O.stringMul(contractsAbs, contractSizeString), markPriceString);
+        }
+        const notional = this.parseNumber(notionalString);
+        const marginMode = this.safeString(position, 'marginMode');
+        let initialMarginString = undefined;
+        const entryPriceString = this.safeString(position, 'averagePrice');
+        const unrealizedPnlString = this.safeString(position, 'unrealizedPnl');
+        const leverageString = this.safeString(position, 'leverage');
+        let initialMarginPercentage = undefined;
+        let collateralString = undefined;
+        if (marginMode === 'cross') {
+            initialMarginString = this.safeString(position, 'initialMargin');
+            collateralString = _base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise */ .O.stringAdd(initialMarginString, unrealizedPnlString);
+        }
+        else if (marginMode === 'isolated') {
+            initialMarginPercentage = _base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise */ .O.stringDiv('1', leverageString);
+            collateralString = this.safeString(position, 'margin');
+        }
+        const maintenanceMarginString = this.safeString(position, 'maintenanceMargin');
+        const maintenanceMargin = this.parseNumber(maintenanceMarginString);
+        const maintenanceMarginPercentageString = _base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise */ .O.stringDiv(maintenanceMarginString, notionalString);
+        if (initialMarginPercentage === undefined) {
+            initialMarginPercentage = this.parseNumber(_base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise */ .O.stringDiv(initialMarginString, notionalString, 4));
+        }
+        else if (initialMarginString === undefined) {
+            initialMarginString = _base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise */ .O.stringMul(initialMarginPercentage, notionalString);
+        }
+        const rounder = '0.00005'; // round to closest 0.01%
+        const maintenanceMarginPercentage = this.parseNumber(_base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise */ .O.stringDiv(_base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise */ .O.stringAdd(maintenanceMarginPercentageString, rounder), '1', 4));
+        const liquidationPrice = this.safeNumber(position, 'liquidationPrice');
+        const percentageString = this.safeString(position, 'unrealizedPnlRatio');
+        const percentage = this.parseNumber(_base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise */ .O.stringMul(percentageString, '100'));
+        const timestamp = this.safeInteger(position, 'updateTime');
+        const marginRatio = this.parseNumber(_base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise */ .O.stringDiv(maintenanceMarginString, collateralString, 4));
+        return this.safePosition({
+            'info': position,
+            'id': undefined,
+            'symbol': symbol,
+            'notional': notional,
+            'marginMode': marginMode,
+            'liquidationPrice': liquidationPrice,
+            'entryPrice': this.parseNumber(entryPriceString),
+            'unrealizedPnl': this.parseNumber(unrealizedPnlString),
+            'percentage': percentage,
+            'contracts': contracts,
+            'contractSize': contractSize,
+            'markPrice': this.parseNumber(markPriceString),
+            'lastPrice': undefined,
+            'side': side,
+            'hedged': hedged,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'lastUpdateTimestamp': undefined,
+            'maintenanceMargin': maintenanceMargin,
+            'maintenanceMarginPercentage': maintenanceMarginPercentage,
+            'collateral': this.parseNumber(collateralString),
+            'initialMargin': this.parseNumber(initialMarginString),
+            'initialMarginPercentage': this.parseNumber(initialMarginPercentage),
+            'leverage': this.parseNumber(leverageString),
+            'marginRatio': marginRatio,
+            'stopLossPrice': undefined,
+            'takeProfitPrice': undefined,
+        });
+    }
+    async fetchLeverage(symbol, params = {}) {
+        /**
+         * @method
+         * @name blofin#fetchLeverage
+         * @description fetch the set leverage for a market
+         * @see https://blofin.com/docs#set-leverage
+         * @param {string} symbol unified market symbol
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {string} [params.marginMode] 'cross' or 'isolated'
+         * @returns {object} a [leverage structure]{@link https://docs.ccxt.com/#/?id=leverage-structure}
+         */
+        await this.loadMarkets();
+        let marginMode = undefined;
+        [marginMode, params] = this.handleMarginModeAndParams('fetchLeverage', params);
+        if (marginMode === undefined) {
+            marginMode = this.safeString(params, 'marginMode', 'cross'); // cross as default marginMode
+        }
+        if ((marginMode !== 'cross') && (marginMode !== 'isolated')) {
+            throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.BadRequest(this.id + ' fetchLeverage() requires a marginMode parameter that must be either cross or isolated');
+        }
+        const market = this.market(symbol);
+        const request = {
+            'instId': market['id'],
+            'marginMode': marginMode,
+        };
+        const response = await this.privateGetAccountLeverageInfo(this.extend(request, params));
+        return response;
+    }
+    async setLeverage(leverage, symbol = undefined, params = {}) {
+        /**
+         * @method
+         * @name blofin#setLeverage
+         * @description set the level of leverage for a market
+         * @see https://blofin.com/docs#set-leverage
+         * @param {int} leverage the rate of leverage
+         * @param {string} symbol unified market symbol
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {string} [params.marginMode] 'cross' or 'isolated'
+         * @returns {object} response from the exchange
+         */
+        if (symbol === undefined) {
+            throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.ArgumentsRequired(this.id + ' setLeverage() requires a symbol argument');
+        }
+        // WARNING: THIS WILL INCREASE LIQUIDATION PRICE FOR OPEN ISOLATED LONG POSITIONS
+        // AND DECREASE LIQUIDATION PRICE FOR OPEN ISOLATED SHORT POSITIONS
+        if ((leverage < 1) || (leverage > 125)) {
+            throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.BadRequest(this.id + ' setLeverage() leverage should be between 1 and 125');
+        }
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        let marginMode = undefined;
+        [marginMode, params] = this.handleMarginModeAndParams('setLeverage', params, 'cross');
+        if ((marginMode !== 'cross') && (marginMode !== 'isolated')) {
+            throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.BadRequest(this.id + ' setLeverage() requires a marginMode parameter that must be either cross or isolated');
+        }
+        const request = {
+            'leverage': leverage,
+            'marginMode': marginMode,
+            'instId': market['id'],
+        };
+        const response = await this.privatePostAccountSetLeverage(this.extend(request, params));
+        return response;
+    }
+    async closePosition(symbol, side = undefined, params = {}) {
+        /**
+         * @method
+         * @name blofin#closePosition
+         * @description closes open positions for a market
+         * @see https://blofin.com/docs#close-positions
+         * @param {string} symbol Unified CCXT market symbol
+         * @param {string} [side] 'buy' or 'sell', leave as undefined in net mode
+         * @param {object} [params] extra parameters specific to the blofin api endpoint
+         * @param {string} [params.clientOrderId] a unique identifier for the order
+         * @param {string} [params.marginMode] 'cross' or 'isolated', default is 'cross;
+         * @param {string} [params.code] *required in the case of closing cross MARGIN position for Single-currency margin* margin currency
+         *
+         * EXCHANGE SPECIFIC PARAMETERS
+         * @param {boolean} [params.autoCxl] whether any pending orders for closing out needs to be automatically canceled when close position via a market order. false or true, the default is false
+         * @param {string} [params.tag] order tag a combination of case-sensitive alphanumerics, all numbers, or all letters of up to 16 characters
+         * @returns {object[]} [A list of position structures]{@link https://docs.ccxt.com/#/?id=position-structure}
+         */
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const clientOrderId = this.safeString(params, 'clientOrderId');
+        let marginMode = undefined;
+        [marginMode, params] = this.handleMarginModeAndParams('closePosition', params, 'cross');
+        const request = {
+            'instId': market['id'],
+            'marginMode': marginMode,
+        };
+        if (clientOrderId !== undefined) {
+            request['clientOrderId'] = clientOrderId;
+        }
+        const response = await this.privatePostTradeClosePosition(this.extend(request, params));
+        return this.safeValue(response, 'data');
+    }
+    async fetchClosedOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name blofin#fetchClosedOrders
+         * @description fetches information on multiple closed orders made by the user
+         * @see https://blofin.com/docs#get-order-history
+         * @see https://blofin.com/docs#get-tpsl-order-history
+         * @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 exchange API endpoint
+         * @param {bool} [params.stop] True if fetching trigger or conditional orders
+         * @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 {Order[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        await this.loadMarkets();
+        let paginate = false;
+        [paginate, params] = this.handleOptionAndParams(params, 'fetchClosedOrders', 'paginate');
+        if (paginate) {
+            return await this.fetchPaginatedCallDynamic('fetchClosedOrders', symbol, since, limit, params);
+        }
+        const request = {};
+        let market = undefined;
+        if (symbol !== undefined) {
+            market = this.market(symbol);
+            request['instId'] = market['id'];
+        }
+        if (limit !== undefined) {
+            request['limit'] = limit; // default 100, max 100
+        }
+        if (since !== undefined) {
+            request['begin'] = since;
+        }
+        const isStop = this.safeValueN(params, ['stop', 'trigger', 'tpsl', 'TPSL'], false);
+        let method = undefined;
+        [method, params] = this.handleOptionAndParams(params, 'fetchOpenOrders', 'method', 'privateGetTradeOrdersHistory');
+        const query = this.omit(params, ['method', 'stop', 'trigger', 'tpsl', 'TPSL']);
+        let response = undefined;
+        if ((isStop) || (method === 'privateGetTradeOrdersTpslHistory')) {
+            response = await this.privateGetTradeOrdersTpslHistory(this.extend(request, query));
+        }
+        else {
+            response = await this.privateGetTradeOrdersHistory(this.extend(request, query));
+        }
+        const data = this.safeList(response, 'data', []);
+        return this.parseOrders(data, market, since, limit);
+    }
+    handleErrors(httpCode, reason, url, method, headers, body, response, requestHeaders, requestBody) {
+        if (response === undefined) {
+            return undefined; // fallback to default error handler
+        }
+        //
+        // {"code":"152002","msg":"Parameter bar error."}
+        //
+        const code = this.safeString(response, 'code');
+        const message = this.safeString(response, 'msg');
+        const feedback = this.id + ' ' + body;
+        if (code !== undefined && code !== '0') {
+            this.throwExactlyMatchedException(this.exceptions['exact'], message, feedback);
+            this.throwExactlyMatchedException(this.exceptions['exact'], code, feedback);
+            this.throwBroadlyMatchedException(this.exceptions['broad'], message, feedback);
+            throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_1__.ExchangeError(feedback); // unknown message
+        }
+        //
+        //  {
+        //      orderId: null,
+        //      clientOrderId: '',
+        //      msg: 'Order failed. Insufficient USDT margin in account',
+        //      code: '103003'
+        //  }
+        //
+        const data = this.safeList(response, 'data');
+        const first = this.safeDict(data, 0);
+        const insideMsg = this.safeString(first, 'msg');
+        const insideCode = this.safeString(first, 'code');
+        if (insideCode !== undefined && insideCode !== '0') {
+            this.throwExactlyMatchedException(this.exceptions['exact'], insideCode, feedback);
+            this.throwExactlyMatchedException(this.exceptions['exact'], insideMsg, feedback);
+            this.throwBroadlyMatchedException(this.exceptions['broad'], insideMsg, feedback);
+        }
+        return undefined;
+    }
+    sign(path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
+        let request = '/api/' + this.version + '/' + this.implodeParams(path, params);
+        const query = this.omit(params, this.extractParams(path));
+        let url = this.implodeHostname(this.urls['api']['rest']) + request;
+        // const type = this.getPathAuthenticationType (path);
+        if (api === 'public') {
+            if (!this.isEmpty(query)) {
+                url += '?' + this.urlencode(query);
+            }
+        }
+        else if (api === 'private') {
+            this.checkRequiredCredentials();
+            const timestamp = this.milliseconds().toString();
+            headers = {
+                'ACCESS-KEY': this.apiKey,
+                'ACCESS-PASSPHRASE': this.password,
+                'ACCESS-TIMESTAMP': timestamp,
+                'ACCESS-NONCE': timestamp,
+            };
+            let sign_body = '';
+            if (method === 'GET') {
+                if (!this.isEmpty(query)) {
+                    const urlencodedQuery = '?' + this.urlencode(query);
+                    url += urlencodedQuery;
+                    request += urlencodedQuery;
+                }
+            }
+            else {
+                if (!this.isEmpty(query)) {
+                    body = this.json(query);
+                    sign_body = body;
+                }
+                headers['Content-Type'] = 'application/json';
+            }
+            const auth = request + method + timestamp + timestamp + sign_body;
+            const signature = this.stringToBase64(this.hmac(this.encode(auth), this.encode(this.secret), _static_dependencies_noble_hashes_sha256_js__WEBPACK_IMPORTED_MODULE_4__/* .sha256 */ .J));
+            headers['ACCESS-SIGN'] = signature;
+        }
+        return { 'url': url, 'method': method, 'body': body, 'headers': headers };
+    }
+}
+
+
 /***/ }),
 
 /***/ 6246:
@@ -250441,6 +252570,7 @@ class kucoin extends _kucoin_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z
                 'watchOrderBook': {
                     'snapshotDelay': 5,
                     'snapshotMaxRetries': 3,
+                    'method': '/market/level2', // '/spotMarket/level2Depth5' or '/spotMarket/level2Depth50'
                 },
             },
             'streaming': {
@@ -250842,10 +252972,15 @@ class kucoin extends _kucoin_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z
         /**
          * @method
          * @name kucoin#watchOrderBook
+         * @see https://www.kucoin.com/docs/websocket/spot-trading/public-channels/level1-bbo-market-data
+         * @see https://www.kucoin.com/docs/websocket/spot-trading/public-channels/level2-market-data
+         * @see https://www.kucoin.com/docs/websocket/spot-trading/public-channels/level2-5-best-ask-bid-orders
+         * @see https://www.kucoin.com/docs/websocket/spot-trading/public-channels/level2-50-best-ask-bid-orders
          * @description watches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
          * @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 exchange API endpoint
+         * @param {string} [params.method] either '/market/level2' or '/spotMarket/level2Depth5' or '/spotMarket/level2Depth50' default is '/market/level2'
          * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
          */
         //
@@ -250869,10 +253004,15 @@ class kucoin extends _kucoin_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z
         /**
          * @method
          * @name kucoin#watchOrderBookForSymbols
+         * @see https://www.kucoin.com/docs/websocket/spot-trading/public-channels/level1-bbo-market-data
+         * @see https://www.kucoin.com/docs/websocket/spot-trading/public-channels/level2-market-data
+         * @see https://www.kucoin.com/docs/websocket/spot-trading/public-channels/level2-5-best-ask-bid-orders
+         * @see https://www.kucoin.com/docs/websocket/spot-trading/public-channels/level2-50-best-ask-bid-orders
          * @description watches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
          * @param {string[]} symbols unified array of symbols
          * @param {int} [limit] the maximum amount of order book entries to return
          * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {string} [params.method] either '/market/level2' or '/spotMarket/level2Depth5' or '/spotMarket/level2Depth50' default is '/market/level2'
          * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
          */
         const symbolsLength = symbols.length;
@@ -250880,28 +253020,36 @@ class kucoin extends _kucoin_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z
             throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.ArgumentsRequired(this.id + ' watchOrderBookForSymbols() requires a non-empty array of symbols');
         }
         if (limit !== undefined) {
-            if ((limit !== 20) && (limit !== 100)) {
-                throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.ExchangeError(this.id + " watchOrderBook 'limit' argument must be undefined, 20 or 100");
+            if ((limit !== 20) && (limit !== 100) && (limit !== 50) && (limit !== 5)) {
+                throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.ExchangeError(this.id + " watchOrderBook 'limit' argument must be undefined, 5, 20, 50 or 100");
             }
         }
         await this.loadMarkets();
         symbols = this.marketSymbols(symbols);
         const marketIds = this.marketIds(symbols);
         const url = await this.negotiate(false);
-        const topic = '/market/level2:' + marketIds.join(',');
+        let method = undefined;
+        [method, params] = this.handleOptionAndParams(params, 'watchOrderBook', 'method', '/market/level2');
+        if ((limit === 5) || (limit === 50)) {
+            method = '/spotMarket/level2Depth' + limit.toString();
+        }
+        const topic = method + ':' + marketIds.join(',');
         const messageHashes = [];
         const subscriptionHashes = [];
         for (let i = 0; i < symbols.length; i++) {
             const symbol = symbols[i];
             messageHashes.push('orderbook:' + symbol);
             const marketId = marketIds[i];
-            subscriptionHashes.push('/market/level2:' + marketId);
+            subscriptionHashes.push(method + ':' + marketId);
+        }
+        let subscription = {};
+        if (method === '/market/level2') { // other streams return the entire orderbook, so we don't need to fetch the snapshot through REST
+            subscription = {
+                'method': this.handleOrderBookSubscription,
+                'symbols': symbols,
+                'limit': limit,
+            };
         }
-        const subscription = {
-            'method': this.handleOrderBookSubscription,
-            'symbols': symbols,
-            'limit': limit,
-        };
         const orderbook = await this.subscribeMultiple(url, messageHashes, topic, subscriptionHashes, params, subscription);
         return orderbook.limit();
     }
@@ -250925,41 +253073,74 @@ class kucoin extends _kucoin_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z
         //         }
         //     }
         //
+        //     {
+        //         "topic": "/spotMarket/level2Depth5:BTC-USDT",
+        //         "type": "message",
+        //         "data": {
+        //             "asks": [
+        //                 [
+        //                     "42815.6",
+        //                     "1.24016245"
+        //                 ]
+        //             ],
+        //             "bids": [
+        //                 [
+        //                     "42815.5",
+        //                     "0.08652716"
+        //                 ]
+        //             ],
+        //             "timestamp": 1707204474018
+        //         },
+        //         "subject": "level2"
+        //     }
+        //
         const data = this.safeValue(message, 'data');
-        const marketId = this.safeString(data, 'symbol');
+        const subject = this.safeString(message, 'subject');
+        const topic = this.safeString(message, 'topic');
+        const topicParts = topic.split(':');
+        const topicSymbol = this.safeString(topicParts, 1);
+        const topicChannel = this.safeString(topicParts, 0);
+        const marketId = this.safeString(data, 'symbol', topicSymbol);
         const symbol = this.safeSymbol(marketId, undefined, '-');
         const messageHash = 'orderbook:' + symbol;
-        const storedOrderBook = this.orderbooks[symbol];
-        const nonce = this.safeInteger(storedOrderBook, 'nonce');
-        const deltaEnd = this.safeInteger(data, 'sequenceEnd');
-        if (nonce === undefined) {
-            const cacheLength = storedOrderBook.cache.length;
-            const topic = this.safeString(message, 'topic');
-            const topicParts = topic.split(':');
-            const topicSymbol = this.safeString(topicParts, 1);
-            const topicChannel = this.safeString(topicParts, 0);
-            const subscriptions = Object.keys(client.subscriptions);
-            let subscription = undefined;
-            for (let i = 0; i < subscriptions.length; i++) {
-                const key = subscriptions[i];
-                if ((key.indexOf(topicSymbol) >= 0) && (key.indexOf(topicChannel) >= 0)) {
-                    subscription = client.subscriptions[key];
-                    break;
-                }
+        let orderbook = this.safeDict(this.orderbooks, symbol);
+        if (subject === 'level2') {
+            if (orderbook === undefined) {
+                orderbook = this.orderBook();
             }
-            const limit = this.safeInteger(subscription, 'limit');
-            const snapshotDelay = this.handleOption('watchOrderBook', 'snapshotDelay', 5);
-            if (cacheLength === snapshotDelay) {
-                this.spawn(this.loadOrderBook, client, messageHash, symbol, limit, {});
+            else {
+                orderbook.reset();
             }
-            storedOrderBook.cache.push(data);
-            return;
+            orderbook['symbol'] = symbol;
         }
-        else if (nonce >= deltaEnd) {
-            return;
+        else {
+            const nonce = this.safeInteger(orderbook, 'nonce');
+            const deltaEnd = this.safeInteger2(data, 'sequenceEnd', 'timestamp');
+            if (nonce === undefined) {
+                const cacheLength = orderbook.cache.length;
+                const subscriptions = Object.keys(client.subscriptions);
+                let subscription = undefined;
+                for (let i = 0; i < subscriptions.length; i++) {
+                    const key = subscriptions[i];
+                    if ((key.indexOf(topicSymbol) >= 0) && (key.indexOf(topicChannel) >= 0)) {
+                        subscription = client.subscriptions[key];
+                        break;
+                    }
+                }
+                const limit = this.safeInteger(subscription, 'limit');
+                const snapshotDelay = this.handleOption('watchOrderBook', 'snapshotDelay', 5);
+                if (cacheLength === snapshotDelay) {
+                    this.spawn(this.loadOrderBook, client, messageHash, symbol, limit, {});
+                }
+                orderbook.cache.push(data);
+                return;
+            }
+            else if (nonce >= deltaEnd) {
+                return;
+            }
         }
-        this.handleDelta(storedOrderBook, data);
-        client.resolve(storedOrderBook, messageHash);
+        this.handleDelta(orderbook, data);
+        client.resolve(orderbook, messageHash);
     }
     getCacheIndex(orderbook, cache) {
         const firstDelta = this.safeValue(cache, 0);
@@ -250979,11 +253160,11 @@ class kucoin extends _kucoin_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z
         return cache.length;
     }
     handleDelta(orderbook, delta) {
-        orderbook['nonce'] = this.safeInteger(delta, 'sequenceEnd');
-        const timestamp = this.safeInteger(delta, 'time');
+        const timestamp = this.safeInteger2(delta, 'time', 'timestamp');
+        orderbook['nonce'] = this.safeInteger(delta, 'sequenceEnd', timestamp);
         orderbook['timestamp'] = timestamp;
         orderbook['datetime'] = this.iso8601(timestamp);
-        const changes = this.safeValue(delta, 'changes');
+        const changes = this.safeValue(delta, 'changes', delta);
         const bids = this.safeValue(changes, 'bids', []);
         const asks = this.safeValue(changes, 'asks', []);
         const storedBids = orderbook['bids'];
@@ -251397,6 +253578,7 @@ class kucoin extends _kucoin_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z
         }
         const subject = this.safeString(message, 'subject');
         const methods = {
+            'level2': this.handleOrderBook,
             'trade.l2update': this.handleOrderBook,
             'trade.ticker': this.handleTicker,
             'trade.snapshot': this.handleTicker,
@@ -301613,39 +303795,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_164__.AccountNotEnabled),
-/* harmony export */   AccountSuspended: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__.AccountSuspended),
-/* harmony export */   AddressPending: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__.AddressPending),
-/* harmony export */   ArgumentsRequired: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__.ArgumentsRequired),
-/* harmony export */   AuthenticationError: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__.AuthenticationError),
-/* harmony export */   BadRequest: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__.BadRequest),
-/* harmony export */   BadResponse: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__.BadResponse),
-/* harmony export */   BadSymbol: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__.BadSymbol),
-/* harmony export */   BaseError: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__.BaseError),
-/* harmony export */   CancelPending: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__.CancelPending),
-/* harmony export */   DDoSProtection: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__.DDoSProtection),
-/* harmony export */   DuplicateOrderId: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__.DuplicateOrderId),
+/* harmony export */   AccountNotEnabled: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.AccountNotEnabled),
+/* harmony export */   AccountSuspended: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.AccountSuspended),
+/* harmony export */   AddressPending: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.AddressPending),
+/* harmony export */   ArgumentsRequired: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.ArgumentsRequired),
+/* harmony export */   AuthenticationError: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.AuthenticationError),
+/* harmony export */   BadRequest: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.BadRequest),
+/* harmony export */   BadResponse: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.BadResponse),
+/* harmony export */   BadSymbol: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.BadSymbol),
+/* harmony export */   BaseError: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.BaseError),
+/* harmony export */   CancelPending: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.CancelPending),
+/* harmony export */   DDoSProtection: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.DDoSProtection),
+/* harmony export */   DuplicateOrderId: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.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_164__.ExchangeError),
-/* harmony export */   ExchangeNotAvailable: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__.ExchangeNotAvailable),
-/* harmony export */   InsufficientFunds: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__.InsufficientFunds),
-/* harmony export */   InvalidAddress: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__.InvalidAddress),
-/* harmony export */   InvalidNonce: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__.InvalidNonce),
-/* harmony export */   InvalidOrder: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__.InvalidOrder),
-/* harmony export */   MarginModeAlreadySet: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__.MarginModeAlreadySet),
-/* harmony export */   NetworkError: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__.NetworkError),
-/* harmony export */   NoChange: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__.NoChange),
-/* harmony export */   NotSupported: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__.NotSupported),
-/* harmony export */   NullResponse: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__.NullResponse),
-/* harmony export */   OnMaintenance: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__.OnMaintenance),
-/* harmony export */   OrderImmediatelyFillable: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__.OrderImmediatelyFillable),
-/* harmony export */   OrderNotCached: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__.OrderNotCached),
-/* harmony export */   OrderNotFillable: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__.OrderNotFillable),
-/* harmony export */   OrderNotFound: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__.OrderNotFound),
-/* harmony export */   PermissionDenied: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__.PermissionDenied),
-/* harmony export */   Precise: () => (/* reexport safe */ _src_base_Precise_js__WEBPACK_IMPORTED_MODULE_162__.O),
-/* harmony export */   RateLimitExceeded: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__.RateLimitExceeded),
-/* harmony export */   RequestTimeout: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__.RequestTimeout),
+/* harmony export */   ExchangeError: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.ExchangeError),
+/* harmony export */   ExchangeNotAvailable: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.ExchangeNotAvailable),
+/* harmony export */   InsufficientFunds: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.InsufficientFunds),
+/* harmony export */   InvalidAddress: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.InvalidAddress),
+/* harmony export */   InvalidNonce: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.InvalidNonce),
+/* harmony export */   InvalidOrder: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.InvalidOrder),
+/* harmony export */   MarginModeAlreadySet: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.MarginModeAlreadySet),
+/* harmony export */   NetworkError: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.NetworkError),
+/* harmony export */   NoChange: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.NoChange),
+/* harmony export */   NotSupported: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.NotSupported),
+/* harmony export */   NullResponse: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.NullResponse),
+/* harmony export */   OnMaintenance: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.OnMaintenance),
+/* harmony export */   OrderImmediatelyFillable: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.OrderImmediatelyFillable),
+/* harmony export */   OrderNotCached: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.OrderNotCached),
+/* harmony export */   OrderNotFillable: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.OrderNotFillable),
+/* harmony export */   OrderNotFound: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.OrderNotFound),
+/* harmony export */   PermissionDenied: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.PermissionDenied),
+/* harmony export */   Precise: () => (/* reexport safe */ _src_base_Precise_js__WEBPACK_IMPORTED_MODULE_163__.O),
+/* harmony export */   RateLimitExceeded: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.RateLimitExceeded),
+/* harmony export */   RequestTimeout: () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__.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),
@@ -301678,85 +303860,86 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   bitvavo: () => (/* reexport safe */ _src_bitvavo_js__WEBPACK_IMPORTED_MODULE_30__.Z),
 /* harmony export */   bl3p: () => (/* reexport safe */ _src_bl3p_js__WEBPACK_IMPORTED_MODULE_31__.Z),
 /* harmony export */   blockchaincom: () => (/* reexport safe */ _src_blockchaincom_js__WEBPACK_IMPORTED_MODULE_32__.Z),
-/* harmony export */   btcalpha: () => (/* reexport safe */ _src_btcalpha_js__WEBPACK_IMPORTED_MODULE_33__.Z),
-/* harmony export */   btcbox: () => (/* reexport safe */ _src_btcbox_js__WEBPACK_IMPORTED_MODULE_34__.Z),
-/* harmony export */   btcmarkets: () => (/* reexport safe */ _src_btcmarkets_js__WEBPACK_IMPORTED_MODULE_35__.Z),
-/* harmony export */   btcturk: () => (/* reexport safe */ _src_btcturk_js__WEBPACK_IMPORTED_MODULE_36__.Z),
-/* harmony export */   bybit: () => (/* reexport safe */ _src_bybit_js__WEBPACK_IMPORTED_MODULE_37__.Z),
-/* harmony export */   cex: () => (/* reexport safe */ _src_cex_js__WEBPACK_IMPORTED_MODULE_38__.Z),
-/* harmony export */   coinbase: () => (/* reexport safe */ _src_coinbase_js__WEBPACK_IMPORTED_MODULE_39__.Z),
-/* harmony export */   coinbasepro: () => (/* reexport safe */ _src_coinbasepro_js__WEBPACK_IMPORTED_MODULE_40__.Z),
-/* harmony export */   coincheck: () => (/* reexport safe */ _src_coincheck_js__WEBPACK_IMPORTED_MODULE_41__.Z),
-/* harmony export */   coinex: () => (/* reexport safe */ _src_coinex_js__WEBPACK_IMPORTED_MODULE_42__.Z),
-/* harmony export */   coinlist: () => (/* reexport safe */ _src_coinlist_js__WEBPACK_IMPORTED_MODULE_43__.Z),
-/* harmony export */   coinmate: () => (/* reexport safe */ _src_coinmate_js__WEBPACK_IMPORTED_MODULE_44__.Z),
-/* harmony export */   coinmetro: () => (/* reexport safe */ _src_coinmetro_js__WEBPACK_IMPORTED_MODULE_45__.Z),
-/* harmony export */   coinone: () => (/* reexport safe */ _src_coinone_js__WEBPACK_IMPORTED_MODULE_46__.Z),
-/* harmony export */   coinsph: () => (/* reexport safe */ _src_coinsph_js__WEBPACK_IMPORTED_MODULE_47__.Z),
-/* harmony export */   coinspot: () => (/* reexport safe */ _src_coinspot_js__WEBPACK_IMPORTED_MODULE_48__.Z),
-/* harmony export */   cryptocom: () => (/* reexport safe */ _src_cryptocom_js__WEBPACK_IMPORTED_MODULE_49__.Z),
-/* harmony export */   currencycom: () => (/* reexport safe */ _src_currencycom_js__WEBPACK_IMPORTED_MODULE_50__.Z),
+/* harmony export */   blofin: () => (/* reexport safe */ _src_blofin_js__WEBPACK_IMPORTED_MODULE_33__.Z),
+/* harmony export */   btcalpha: () => (/* reexport safe */ _src_btcalpha_js__WEBPACK_IMPORTED_MODULE_34__.Z),
+/* harmony export */   btcbox: () => (/* reexport safe */ _src_btcbox_js__WEBPACK_IMPORTED_MODULE_35__.Z),
+/* harmony export */   btcmarkets: () => (/* reexport safe */ _src_btcmarkets_js__WEBPACK_IMPORTED_MODULE_36__.Z),
+/* harmony export */   btcturk: () => (/* reexport safe */ _src_btcturk_js__WEBPACK_IMPORTED_MODULE_37__.Z),
+/* harmony export */   bybit: () => (/* reexport safe */ _src_bybit_js__WEBPACK_IMPORTED_MODULE_38__.Z),
+/* harmony export */   cex: () => (/* reexport safe */ _src_cex_js__WEBPACK_IMPORTED_MODULE_39__.Z),
+/* harmony export */   coinbase: () => (/* reexport safe */ _src_coinbase_js__WEBPACK_IMPORTED_MODULE_40__.Z),
+/* harmony export */   coinbasepro: () => (/* reexport safe */ _src_coinbasepro_js__WEBPACK_IMPORTED_MODULE_41__.Z),
+/* harmony export */   coincheck: () => (/* reexport safe */ _src_coincheck_js__WEBPACK_IMPORTED_MODULE_42__.Z),
+/* harmony export */   coinex: () => (/* reexport safe */ _src_coinex_js__WEBPACK_IMPORTED_MODULE_43__.Z),
+/* harmony export */   coinlist: () => (/* reexport safe */ _src_coinlist_js__WEBPACK_IMPORTED_MODULE_44__.Z),
+/* harmony export */   coinmate: () => (/* reexport safe */ _src_coinmate_js__WEBPACK_IMPORTED_MODULE_45__.Z),
+/* harmony export */   coinmetro: () => (/* reexport safe */ _src_coinmetro_js__WEBPACK_IMPORTED_MODULE_46__.Z),
+/* harmony export */   coinone: () => (/* reexport safe */ _src_coinone_js__WEBPACK_IMPORTED_MODULE_47__.Z),
+/* harmony export */   coinsph: () => (/* reexport safe */ _src_coinsph_js__WEBPACK_IMPORTED_MODULE_48__.Z),
+/* harmony export */   coinspot: () => (/* reexport safe */ _src_coinspot_js__WEBPACK_IMPORTED_MODULE_49__.Z),
+/* harmony export */   cryptocom: () => (/* reexport safe */ _src_cryptocom_js__WEBPACK_IMPORTED_MODULE_50__.Z),
+/* harmony export */   currencycom: () => (/* reexport safe */ _src_currencycom_js__WEBPACK_IMPORTED_MODULE_51__.Z),
 /* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__),
-/* harmony export */   delta: () => (/* reexport safe */ _src_delta_js__WEBPACK_IMPORTED_MODULE_51__.Z),
-/* harmony export */   deribit: () => (/* reexport safe */ _src_deribit_js__WEBPACK_IMPORTED_MODULE_52__.Z),
-/* harmony export */   digifinex: () => (/* reexport safe */ _src_digifinex_js__WEBPACK_IMPORTED_MODULE_53__.Z),
-/* harmony export */   errors: () => (/* reexport module object */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__),
+/* harmony export */   delta: () => (/* reexport safe */ _src_delta_js__WEBPACK_IMPORTED_MODULE_52__.Z),
+/* harmony export */   deribit: () => (/* reexport safe */ _src_deribit_js__WEBPACK_IMPORTED_MODULE_53__.Z),
+/* harmony export */   digifinex: () => (/* reexport safe */ _src_digifinex_js__WEBPACK_IMPORTED_MODULE_54__.Z),
+/* harmony export */   errors: () => (/* reexport module object */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__),
 /* harmony export */   exchanges: () => (/* binding */ exchanges),
-/* harmony export */   exmo: () => (/* reexport safe */ _src_exmo_js__WEBPACK_IMPORTED_MODULE_54__.Z),
-/* harmony export */   fmfwio: () => (/* reexport safe */ _src_fmfwio_js__WEBPACK_IMPORTED_MODULE_55__.Z),
-/* harmony export */   functions: () => (/* reexport module object */ _src_base_functions_js__WEBPACK_IMPORTED_MODULE_163__),
-/* harmony export */   gate: () => (/* reexport safe */ _src_gate_js__WEBPACK_IMPORTED_MODULE_56__.Z),
-/* harmony export */   gateio: () => (/* reexport safe */ _src_gateio_js__WEBPACK_IMPORTED_MODULE_57__.Z),
-/* harmony export */   gemini: () => (/* reexport safe */ _src_gemini_js__WEBPACK_IMPORTED_MODULE_58__.Z),
-/* harmony export */   hitbtc: () => (/* reexport safe */ _src_hitbtc_js__WEBPACK_IMPORTED_MODULE_59__.Z),
-/* harmony export */   hitbtc3: () => (/* reexport safe */ _src_hitbtc3_js__WEBPACK_IMPORTED_MODULE_60__.Z),
-/* harmony export */   hollaex: () => (/* reexport safe */ _src_hollaex_js__WEBPACK_IMPORTED_MODULE_61__.Z),
-/* harmony export */   htx: () => (/* reexport safe */ _src_htx_js__WEBPACK_IMPORTED_MODULE_62__.Z),
-/* harmony export */   huobi: () => (/* reexport safe */ _src_huobi_js__WEBPACK_IMPORTED_MODULE_63__.Z),
-/* harmony export */   huobijp: () => (/* reexport safe */ _src_huobijp_js__WEBPACK_IMPORTED_MODULE_64__.Z),
-/* harmony export */   idex: () => (/* reexport safe */ _src_idex_js__WEBPACK_IMPORTED_MODULE_65__.Z),
-/* harmony export */   independentreserve: () => (/* reexport safe */ _src_independentreserve_js__WEBPACK_IMPORTED_MODULE_66__.Z),
-/* harmony export */   indodax: () => (/* reexport safe */ _src_indodax_js__WEBPACK_IMPORTED_MODULE_67__.Z),
-/* harmony export */   kraken: () => (/* reexport safe */ _src_kraken_js__WEBPACK_IMPORTED_MODULE_68__.Z),
-/* harmony export */   krakenfutures: () => (/* reexport safe */ _src_krakenfutures_js__WEBPACK_IMPORTED_MODULE_69__.Z),
-/* harmony export */   kucoin: () => (/* reexport safe */ _src_kucoin_js__WEBPACK_IMPORTED_MODULE_70__.Z),
-/* harmony export */   kucoinfutures: () => (/* reexport safe */ _src_kucoinfutures_js__WEBPACK_IMPORTED_MODULE_71__.Z),
-/* harmony export */   kuna: () => (/* reexport safe */ _src_kuna_js__WEBPACK_IMPORTED_MODULE_72__.Z),
-/* harmony export */   latoken: () => (/* reexport safe */ _src_latoken_js__WEBPACK_IMPORTED_MODULE_73__.Z),
-/* harmony export */   lbank: () => (/* reexport safe */ _src_lbank_js__WEBPACK_IMPORTED_MODULE_74__.Z),
-/* harmony export */   luno: () => (/* reexport safe */ _src_luno_js__WEBPACK_IMPORTED_MODULE_75__.Z),
-/* harmony export */   lykke: () => (/* reexport safe */ _src_lykke_js__WEBPACK_IMPORTED_MODULE_76__.Z),
-/* harmony export */   mercado: () => (/* reexport safe */ _src_mercado_js__WEBPACK_IMPORTED_MODULE_77__.Z),
-/* harmony export */   mexc: () => (/* reexport safe */ _src_mexc_js__WEBPACK_IMPORTED_MODULE_78__.Z),
-/* harmony export */   ndax: () => (/* reexport safe */ _src_ndax_js__WEBPACK_IMPORTED_MODULE_79__.Z),
-/* harmony export */   novadax: () => (/* reexport safe */ _src_novadax_js__WEBPACK_IMPORTED_MODULE_80__.Z),
-/* harmony export */   oceanex: () => (/* reexport safe */ _src_oceanex_js__WEBPACK_IMPORTED_MODULE_81__.Z),
-/* harmony export */   okcoin: () => (/* reexport safe */ _src_okcoin_js__WEBPACK_IMPORTED_MODULE_82__.Z),
-/* harmony export */   okx: () => (/* reexport safe */ _src_okx_js__WEBPACK_IMPORTED_MODULE_83__.Z),
-/* harmony export */   onetrading: () => (/* reexport safe */ _src_onetrading_js__WEBPACK_IMPORTED_MODULE_84__.Z),
-/* harmony export */   p2b: () => (/* reexport safe */ _src_p2b_js__WEBPACK_IMPORTED_MODULE_85__.Z),
-/* harmony export */   paymium: () => (/* reexport safe */ _src_paymium_js__WEBPACK_IMPORTED_MODULE_86__.Z),
-/* harmony export */   phemex: () => (/* reexport safe */ _src_phemex_js__WEBPACK_IMPORTED_MODULE_87__.Z),
-/* harmony export */   poloniex: () => (/* reexport safe */ _src_poloniex_js__WEBPACK_IMPORTED_MODULE_88__.Z),
-/* harmony export */   poloniexfutures: () => (/* reexport safe */ _src_poloniexfutures_js__WEBPACK_IMPORTED_MODULE_89__.Z),
+/* harmony export */   exmo: () => (/* reexport safe */ _src_exmo_js__WEBPACK_IMPORTED_MODULE_55__.Z),
+/* harmony export */   fmfwio: () => (/* reexport safe */ _src_fmfwio_js__WEBPACK_IMPORTED_MODULE_56__.Z),
+/* harmony export */   functions: () => (/* reexport module object */ _src_base_functions_js__WEBPACK_IMPORTED_MODULE_164__),
+/* harmony export */   gate: () => (/* reexport safe */ _src_gate_js__WEBPACK_IMPORTED_MODULE_57__.Z),
+/* harmony export */   gateio: () => (/* reexport safe */ _src_gateio_js__WEBPACK_IMPORTED_MODULE_58__.Z),
+/* harmony export */   gemini: () => (/* reexport safe */ _src_gemini_js__WEBPACK_IMPORTED_MODULE_59__.Z),
+/* harmony export */   hitbtc: () => (/* reexport safe */ _src_hitbtc_js__WEBPACK_IMPORTED_MODULE_60__.Z),
+/* harmony export */   hitbtc3: () => (/* reexport safe */ _src_hitbtc3_js__WEBPACK_IMPORTED_MODULE_61__.Z),
+/* harmony export */   hollaex: () => (/* reexport safe */ _src_hollaex_js__WEBPACK_IMPORTED_MODULE_62__.Z),
+/* harmony export */   htx: () => (/* reexport safe */ _src_htx_js__WEBPACK_IMPORTED_MODULE_63__.Z),
+/* harmony export */   huobi: () => (/* reexport safe */ _src_huobi_js__WEBPACK_IMPORTED_MODULE_64__.Z),
+/* harmony export */   huobijp: () => (/* reexport safe */ _src_huobijp_js__WEBPACK_IMPORTED_MODULE_65__.Z),
+/* harmony export */   idex: () => (/* reexport safe */ _src_idex_js__WEBPACK_IMPORTED_MODULE_66__.Z),
+/* harmony export */   independentreserve: () => (/* reexport safe */ _src_independentreserve_js__WEBPACK_IMPORTED_MODULE_67__.Z),
+/* harmony export */   indodax: () => (/* reexport safe */ _src_indodax_js__WEBPACK_IMPORTED_MODULE_68__.Z),
+/* harmony export */   kraken: () => (/* reexport safe */ _src_kraken_js__WEBPACK_IMPORTED_MODULE_69__.Z),
+/* harmony export */   krakenfutures: () => (/* reexport safe */ _src_krakenfutures_js__WEBPACK_IMPORTED_MODULE_70__.Z),
+/* harmony export */   kucoin: () => (/* reexport safe */ _src_kucoin_js__WEBPACK_IMPORTED_MODULE_71__.Z),
+/* harmony export */   kucoinfutures: () => (/* reexport safe */ _src_kucoinfutures_js__WEBPACK_IMPORTED_MODULE_72__.Z),
+/* harmony export */   kuna: () => (/* reexport safe */ _src_kuna_js__WEBPACK_IMPORTED_MODULE_73__.Z),
+/* harmony export */   latoken: () => (/* reexport safe */ _src_latoken_js__WEBPACK_IMPORTED_MODULE_74__.Z),
+/* harmony export */   lbank: () => (/* reexport safe */ _src_lbank_js__WEBPACK_IMPORTED_MODULE_75__.Z),
+/* harmony export */   luno: () => (/* reexport safe */ _src_luno_js__WEBPACK_IMPORTED_MODULE_76__.Z),
+/* harmony export */   lykke: () => (/* reexport safe */ _src_lykke_js__WEBPACK_IMPORTED_MODULE_77__.Z),
+/* harmony export */   mercado: () => (/* reexport safe */ _src_mercado_js__WEBPACK_IMPORTED_MODULE_78__.Z),
+/* harmony export */   mexc: () => (/* reexport safe */ _src_mexc_js__WEBPACK_IMPORTED_MODULE_79__.Z),
+/* harmony export */   ndax: () => (/* reexport safe */ _src_ndax_js__WEBPACK_IMPORTED_MODULE_80__.Z),
+/* harmony export */   novadax: () => (/* reexport safe */ _src_novadax_js__WEBPACK_IMPORTED_MODULE_81__.Z),
+/* harmony export */   oceanex: () => (/* reexport safe */ _src_oceanex_js__WEBPACK_IMPORTED_MODULE_82__.Z),
+/* harmony export */   okcoin: () => (/* reexport safe */ _src_okcoin_js__WEBPACK_IMPORTED_MODULE_83__.Z),
+/* harmony export */   okx: () => (/* reexport safe */ _src_okx_js__WEBPACK_IMPORTED_MODULE_84__.Z),
+/* harmony export */   onetrading: () => (/* reexport safe */ _src_onetrading_js__WEBPACK_IMPORTED_MODULE_85__.Z),
+/* harmony export */   p2b: () => (/* reexport safe */ _src_p2b_js__WEBPACK_IMPORTED_MODULE_86__.Z),
+/* harmony export */   paymium: () => (/* reexport safe */ _src_paymium_js__WEBPACK_IMPORTED_MODULE_87__.Z),
+/* harmony export */   phemex: () => (/* reexport safe */ _src_phemex_js__WEBPACK_IMPORTED_MODULE_88__.Z),
+/* harmony export */   poloniex: () => (/* reexport safe */ _src_poloniex_js__WEBPACK_IMPORTED_MODULE_89__.Z),
+/* harmony export */   poloniexfutures: () => (/* reexport safe */ _src_poloniexfutures_js__WEBPACK_IMPORTED_MODULE_90__.Z),
 /* harmony export */   pro: () => (/* binding */ pro),
-/* harmony export */   probit: () => (/* reexport safe */ _src_probit_js__WEBPACK_IMPORTED_MODULE_90__.Z),
-/* harmony export */   timex: () => (/* reexport safe */ _src_timex_js__WEBPACK_IMPORTED_MODULE_91__.Z),
-/* harmony export */   tokocrypto: () => (/* reexport safe */ _src_tokocrypto_js__WEBPACK_IMPORTED_MODULE_92__.Z),
-/* harmony export */   upbit: () => (/* reexport safe */ _src_upbit_js__WEBPACK_IMPORTED_MODULE_93__.Z),
+/* harmony export */   probit: () => (/* reexport safe */ _src_probit_js__WEBPACK_IMPORTED_MODULE_91__.Z),
+/* harmony export */   timex: () => (/* reexport safe */ _src_timex_js__WEBPACK_IMPORTED_MODULE_92__.Z),
+/* harmony export */   tokocrypto: () => (/* reexport safe */ _src_tokocrypto_js__WEBPACK_IMPORTED_MODULE_93__.Z),
+/* harmony export */   upbit: () => (/* reexport safe */ _src_upbit_js__WEBPACK_IMPORTED_MODULE_94__.Z),
 /* harmony export */   version: () => (/* binding */ version),
-/* harmony export */   wavesexchange: () => (/* reexport safe */ _src_wavesexchange_js__WEBPACK_IMPORTED_MODULE_94__.Z),
-/* harmony export */   wazirx: () => (/* reexport safe */ _src_wazirx_js__WEBPACK_IMPORTED_MODULE_95__.Z),
-/* harmony export */   whitebit: () => (/* reexport safe */ _src_whitebit_js__WEBPACK_IMPORTED_MODULE_96__.Z),
-/* harmony export */   woo: () => (/* reexport safe */ _src_woo_js__WEBPACK_IMPORTED_MODULE_97__.Z),
-/* harmony export */   yobit: () => (/* reexport safe */ _src_yobit_js__WEBPACK_IMPORTED_MODULE_98__.Z),
-/* harmony export */   zaif: () => (/* reexport safe */ _src_zaif_js__WEBPACK_IMPORTED_MODULE_99__.Z),
-/* harmony export */   zonda: () => (/* reexport safe */ _src_zonda_js__WEBPACK_IMPORTED_MODULE_100__.Z)
+/* harmony export */   wavesexchange: () => (/* reexport safe */ _src_wavesexchange_js__WEBPACK_IMPORTED_MODULE_95__.Z),
+/* harmony export */   wazirx: () => (/* reexport safe */ _src_wazirx_js__WEBPACK_IMPORTED_MODULE_96__.Z),
+/* harmony export */   whitebit: () => (/* reexport safe */ _src_whitebit_js__WEBPACK_IMPORTED_MODULE_97__.Z),
+/* harmony export */   woo: () => (/* reexport safe */ _src_woo_js__WEBPACK_IMPORTED_MODULE_98__.Z),
+/* harmony export */   yobit: () => (/* reexport safe */ _src_yobit_js__WEBPACK_IMPORTED_MODULE_99__.Z),
+/* harmony export */   zaif: () => (/* reexport safe */ _src_zaif_js__WEBPACK_IMPORTED_MODULE_100__.Z),
+/* harmony export */   zonda: () => (/* reexport safe */ _src_zonda_js__WEBPACK_IMPORTED_MODULE_101__.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_162__ = __webpack_require__(2194);
-/* harmony import */ var _src_base_functions_js__WEBPACK_IMPORTED_MODULE_163__ = __webpack_require__(7100);
-/* harmony import */ var _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__ = __webpack_require__(6689);
+/* harmony import */ var _src_base_Precise_js__WEBPACK_IMPORTED_MODULE_163__ = __webpack_require__(2194);
+/* harmony import */ var _src_base_functions_js__WEBPACK_IMPORTED_MODULE_164__ = __webpack_require__(7100);
+/* harmony import */ var _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__ = __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);
@@ -301789,135 +303972,136 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _src_bitvavo_js__WEBPACK_IMPORTED_MODULE_30__ = __webpack_require__(9943);
 /* harmony import */ var _src_bl3p_js__WEBPACK_IMPORTED_MODULE_31__ = __webpack_require__(9476);
 /* harmony import */ var _src_blockchaincom_js__WEBPACK_IMPORTED_MODULE_32__ = __webpack_require__(182);
-/* harmony import */ var _src_btcalpha_js__WEBPACK_IMPORTED_MODULE_33__ = __webpack_require__(6246);
-/* harmony import */ var _src_btcbox_js__WEBPACK_IMPORTED_MODULE_34__ = __webpack_require__(7796);
-/* harmony import */ var _src_btcmarkets_js__WEBPACK_IMPORTED_MODULE_35__ = __webpack_require__(1776);
-/* harmony import */ var _src_btcturk_js__WEBPACK_IMPORTED_MODULE_36__ = __webpack_require__(6304);
-/* harmony import */ var _src_bybit_js__WEBPACK_IMPORTED_MODULE_37__ = __webpack_require__(3527);
-/* harmony import */ var _src_cex_js__WEBPACK_IMPORTED_MODULE_38__ = __webpack_require__(6445);
-/* harmony import */ var _src_coinbase_js__WEBPACK_IMPORTED_MODULE_39__ = __webpack_require__(437);
-/* harmony import */ var _src_coinbasepro_js__WEBPACK_IMPORTED_MODULE_40__ = __webpack_require__(8856);
-/* harmony import */ var _src_coincheck_js__WEBPACK_IMPORTED_MODULE_41__ = __webpack_require__(2117);
-/* harmony import */ var _src_coinex_js__WEBPACK_IMPORTED_MODULE_42__ = __webpack_require__(332);
-/* harmony import */ var _src_coinlist_js__WEBPACK_IMPORTED_MODULE_43__ = __webpack_require__(3623);
-/* harmony import */ var _src_coinmate_js__WEBPACK_IMPORTED_MODULE_44__ = __webpack_require__(9816);
-/* harmony import */ var _src_coinmetro_js__WEBPACK_IMPORTED_MODULE_45__ = __webpack_require__(4759);
-/* harmony import */ var _src_coinone_js__WEBPACK_IMPORTED_MODULE_46__ = __webpack_require__(7811);
-/* harmony import */ var _src_coinsph_js__WEBPACK_IMPORTED_MODULE_47__ = __webpack_require__(5782);
-/* harmony import */ var _src_coinspot_js__WEBPACK_IMPORTED_MODULE_48__ = __webpack_require__(7794);
-/* harmony import */ var _src_cryptocom_js__WEBPACK_IMPORTED_MODULE_49__ = __webpack_require__(9129);
-/* harmony import */ var _src_currencycom_js__WEBPACK_IMPORTED_MODULE_50__ = __webpack_require__(3214);
-/* harmony import */ var _src_delta_js__WEBPACK_IMPORTED_MODULE_51__ = __webpack_require__(1753);
-/* harmony import */ var _src_deribit_js__WEBPACK_IMPORTED_MODULE_52__ = __webpack_require__(24);
-/* harmony import */ var _src_digifinex_js__WEBPACK_IMPORTED_MODULE_53__ = __webpack_require__(8846);
-/* harmony import */ var _src_exmo_js__WEBPACK_IMPORTED_MODULE_54__ = __webpack_require__(1729);
-/* harmony import */ var _src_fmfwio_js__WEBPACK_IMPORTED_MODULE_55__ = __webpack_require__(5788);
-/* harmony import */ var _src_gate_js__WEBPACK_IMPORTED_MODULE_56__ = __webpack_require__(7290);
-/* harmony import */ var _src_gateio_js__WEBPACK_IMPORTED_MODULE_57__ = __webpack_require__(7036);
-/* harmony import */ var _src_gemini_js__WEBPACK_IMPORTED_MODULE_58__ = __webpack_require__(6743);
-/* harmony import */ var _src_hitbtc_js__WEBPACK_IMPORTED_MODULE_59__ = __webpack_require__(4714);
-/* harmony import */ var _src_hitbtc3_js__WEBPACK_IMPORTED_MODULE_60__ = __webpack_require__(4815);
-/* harmony import */ var _src_hollaex_js__WEBPACK_IMPORTED_MODULE_61__ = __webpack_require__(8422);
-/* harmony import */ var _src_htx_js__WEBPACK_IMPORTED_MODULE_62__ = __webpack_require__(5939);
-/* harmony import */ var _src_huobi_js__WEBPACK_IMPORTED_MODULE_63__ = __webpack_require__(8146);
-/* harmony import */ var _src_huobijp_js__WEBPACK_IMPORTED_MODULE_64__ = __webpack_require__(7034);
-/* harmony import */ var _src_idex_js__WEBPACK_IMPORTED_MODULE_65__ = __webpack_require__(8232);
-/* harmony import */ var _src_independentreserve_js__WEBPACK_IMPORTED_MODULE_66__ = __webpack_require__(9570);
-/* harmony import */ var _src_indodax_js__WEBPACK_IMPORTED_MODULE_67__ = __webpack_require__(1605);
-/* harmony import */ var _src_kraken_js__WEBPACK_IMPORTED_MODULE_68__ = __webpack_require__(9922);
-/* harmony import */ var _src_krakenfutures_js__WEBPACK_IMPORTED_MODULE_69__ = __webpack_require__(4470);
-/* harmony import */ var _src_kucoin_js__WEBPACK_IMPORTED_MODULE_70__ = __webpack_require__(3583);
-/* harmony import */ var _src_kucoinfutures_js__WEBPACK_IMPORTED_MODULE_71__ = __webpack_require__(1924);
-/* harmony import */ var _src_kuna_js__WEBPACK_IMPORTED_MODULE_72__ = __webpack_require__(7732);
-/* harmony import */ var _src_latoken_js__WEBPACK_IMPORTED_MODULE_73__ = __webpack_require__(2545);
-/* harmony import */ var _src_lbank_js__WEBPACK_IMPORTED_MODULE_74__ = __webpack_require__(3944);
-/* harmony import */ var _src_luno_js__WEBPACK_IMPORTED_MODULE_75__ = __webpack_require__(1758);
-/* harmony import */ var _src_lykke_js__WEBPACK_IMPORTED_MODULE_76__ = __webpack_require__(3803);
-/* harmony import */ var _src_mercado_js__WEBPACK_IMPORTED_MODULE_77__ = __webpack_require__(9013);
-/* harmony import */ var _src_mexc_js__WEBPACK_IMPORTED_MODULE_78__ = __webpack_require__(6641);
-/* harmony import */ var _src_ndax_js__WEBPACK_IMPORTED_MODULE_79__ = __webpack_require__(4531);
-/* harmony import */ var _src_novadax_js__WEBPACK_IMPORTED_MODULE_80__ = __webpack_require__(2449);
-/* harmony import */ var _src_oceanex_js__WEBPACK_IMPORTED_MODULE_81__ = __webpack_require__(6749);
-/* harmony import */ var _src_okcoin_js__WEBPACK_IMPORTED_MODULE_82__ = __webpack_require__(3007);
-/* harmony import */ var _src_okx_js__WEBPACK_IMPORTED_MODULE_83__ = __webpack_require__(4042);
-/* harmony import */ var _src_onetrading_js__WEBPACK_IMPORTED_MODULE_84__ = __webpack_require__(6481);
-/* harmony import */ var _src_p2b_js__WEBPACK_IMPORTED_MODULE_85__ = __webpack_require__(2466);
-/* harmony import */ var _src_paymium_js__WEBPACK_IMPORTED_MODULE_86__ = __webpack_require__(7082);
-/* harmony import */ var _src_phemex_js__WEBPACK_IMPORTED_MODULE_87__ = __webpack_require__(79);
-/* harmony import */ var _src_poloniex_js__WEBPACK_IMPORTED_MODULE_88__ = __webpack_require__(8891);
-/* harmony import */ var _src_poloniexfutures_js__WEBPACK_IMPORTED_MODULE_89__ = __webpack_require__(6877);
-/* harmony import */ var _src_probit_js__WEBPACK_IMPORTED_MODULE_90__ = __webpack_require__(3657);
-/* harmony import */ var _src_timex_js__WEBPACK_IMPORTED_MODULE_91__ = __webpack_require__(1067);
-/* harmony import */ var _src_tokocrypto_js__WEBPACK_IMPORTED_MODULE_92__ = __webpack_require__(5261);
-/* harmony import */ var _src_upbit_js__WEBPACK_IMPORTED_MODULE_93__ = __webpack_require__(7584);
-/* harmony import */ var _src_wavesexchange_js__WEBPACK_IMPORTED_MODULE_94__ = __webpack_require__(3853);
-/* harmony import */ var _src_wazirx_js__WEBPACK_IMPORTED_MODULE_95__ = __webpack_require__(6536);
-/* harmony import */ var _src_whitebit_js__WEBPACK_IMPORTED_MODULE_96__ = __webpack_require__(5467);
-/* harmony import */ var _src_woo_js__WEBPACK_IMPORTED_MODULE_97__ = __webpack_require__(517);
-/* harmony import */ var _src_yobit_js__WEBPACK_IMPORTED_MODULE_98__ = __webpack_require__(3850);
-/* harmony import */ var _src_zaif_js__WEBPACK_IMPORTED_MODULE_99__ = __webpack_require__(5934);
-/* harmony import */ var _src_zonda_js__WEBPACK_IMPORTED_MODULE_100__ = __webpack_require__(5140);
-/* harmony import */ var _src_pro_alpaca_js__WEBPACK_IMPORTED_MODULE_101__ = __webpack_require__(2467);
-/* harmony import */ var _src_pro_ascendex_js__WEBPACK_IMPORTED_MODULE_102__ = __webpack_require__(2383);
-/* harmony import */ var _src_pro_bequant_js__WEBPACK_IMPORTED_MODULE_103__ = __webpack_require__(8848);
-/* harmony import */ var _src_pro_binance_js__WEBPACK_IMPORTED_MODULE_104__ = __webpack_require__(8764);
-/* harmony import */ var _src_pro_binancecoinm_js__WEBPACK_IMPORTED_MODULE_105__ = __webpack_require__(5078);
-/* harmony import */ var _src_pro_binanceus_js__WEBPACK_IMPORTED_MODULE_106__ = __webpack_require__(1326);
-/* harmony import */ var _src_pro_binanceusdm_js__WEBPACK_IMPORTED_MODULE_107__ = __webpack_require__(1230);
-/* harmony import */ var _src_pro_bingx_js__WEBPACK_IMPORTED_MODULE_108__ = __webpack_require__(6955);
-/* harmony import */ var _src_pro_bitcoincom_js__WEBPACK_IMPORTED_MODULE_109__ = __webpack_require__(453);
-/* harmony import */ var _src_pro_bitfinex_js__WEBPACK_IMPORTED_MODULE_110__ = __webpack_require__(9772);
-/* harmony import */ var _src_pro_bitfinex2_js__WEBPACK_IMPORTED_MODULE_111__ = __webpack_require__(588);
-/* harmony import */ var _src_pro_bitget_js__WEBPACK_IMPORTED_MODULE_112__ = __webpack_require__(1885);
-/* harmony import */ var _src_pro_bitmart_js__WEBPACK_IMPORTED_MODULE_113__ = __webpack_require__(7504);
-/* harmony import */ var _src_pro_bitmex_js__WEBPACK_IMPORTED_MODULE_114__ = __webpack_require__(2302);
-/* harmony import */ var _src_pro_bitopro_js__WEBPACK_IMPORTED_MODULE_115__ = __webpack_require__(2191);
-/* harmony import */ var _src_pro_bitpanda_js__WEBPACK_IMPORTED_MODULE_116__ = __webpack_require__(1297);
-/* harmony import */ var _src_pro_bitrue_js__WEBPACK_IMPORTED_MODULE_117__ = __webpack_require__(3005);
-/* harmony import */ var _src_pro_bitstamp_js__WEBPACK_IMPORTED_MODULE_118__ = __webpack_require__(2317);
-/* harmony import */ var _src_pro_bitvavo_js__WEBPACK_IMPORTED_MODULE_119__ = __webpack_require__(6977);
-/* harmony import */ var _src_pro_blockchaincom_js__WEBPACK_IMPORTED_MODULE_120__ = __webpack_require__(2519);
-/* harmony import */ var _src_pro_bybit_js__WEBPACK_IMPORTED_MODULE_121__ = __webpack_require__(5030);
-/* harmony import */ var _src_pro_cex_js__WEBPACK_IMPORTED_MODULE_122__ = __webpack_require__(5272);
-/* harmony import */ var _src_pro_coinbase_js__WEBPACK_IMPORTED_MODULE_123__ = __webpack_require__(3414);
-/* harmony import */ var _src_pro_coinbasepro_js__WEBPACK_IMPORTED_MODULE_124__ = __webpack_require__(8368);
-/* harmony import */ var _src_pro_coincheck_js__WEBPACK_IMPORTED_MODULE_125__ = __webpack_require__(7891);
-/* harmony import */ var _src_pro_coinex_js__WEBPACK_IMPORTED_MODULE_126__ = __webpack_require__(204);
-/* harmony import */ var _src_pro_coinone_js__WEBPACK_IMPORTED_MODULE_127__ = __webpack_require__(5208);
-/* harmony import */ var _src_pro_cryptocom_js__WEBPACK_IMPORTED_MODULE_128__ = __webpack_require__(6820);
-/* harmony import */ var _src_pro_currencycom_js__WEBPACK_IMPORTED_MODULE_129__ = __webpack_require__(2952);
-/* harmony import */ var _src_pro_deribit_js__WEBPACK_IMPORTED_MODULE_130__ = __webpack_require__(1788);
-/* harmony import */ var _src_pro_exmo_js__WEBPACK_IMPORTED_MODULE_131__ = __webpack_require__(9004);
-/* harmony import */ var _src_pro_gate_js__WEBPACK_IMPORTED_MODULE_132__ = __webpack_require__(8335);
-/* harmony import */ var _src_pro_gateio_js__WEBPACK_IMPORTED_MODULE_133__ = __webpack_require__(1465);
-/* harmony import */ var _src_pro_gemini_js__WEBPACK_IMPORTED_MODULE_134__ = __webpack_require__(9488);
-/* harmony import */ var _src_pro_hitbtc_js__WEBPACK_IMPORTED_MODULE_135__ = __webpack_require__(5189);
-/* harmony import */ var _src_pro_hollaex_js__WEBPACK_IMPORTED_MODULE_136__ = __webpack_require__(8559);
-/* harmony import */ var _src_pro_htx_js__WEBPACK_IMPORTED_MODULE_137__ = __webpack_require__(7474);
-/* harmony import */ var _src_pro_huobi_js__WEBPACK_IMPORTED_MODULE_138__ = __webpack_require__(8384);
-/* harmony import */ var _src_pro_huobijp_js__WEBPACK_IMPORTED_MODULE_139__ = __webpack_require__(9021);
-/* harmony import */ var _src_pro_idex_js__WEBPACK_IMPORTED_MODULE_140__ = __webpack_require__(3484);
-/* harmony import */ var _src_pro_independentreserve_js__WEBPACK_IMPORTED_MODULE_141__ = __webpack_require__(1311);
-/* harmony import */ var _src_pro_kraken_js__WEBPACK_IMPORTED_MODULE_142__ = __webpack_require__(736);
-/* harmony import */ var _src_pro_krakenfutures_js__WEBPACK_IMPORTED_MODULE_143__ = __webpack_require__(449);
-/* harmony import */ var _src_pro_kucoin_js__WEBPACK_IMPORTED_MODULE_144__ = __webpack_require__(2387);
-/* harmony import */ var _src_pro_kucoinfutures_js__WEBPACK_IMPORTED_MODULE_145__ = __webpack_require__(7181);
-/* harmony import */ var _src_pro_lbank_js__WEBPACK_IMPORTED_MODULE_146__ = __webpack_require__(1267);
-/* harmony import */ var _src_pro_luno_js__WEBPACK_IMPORTED_MODULE_147__ = __webpack_require__(627);
-/* harmony import */ var _src_pro_mexc_js__WEBPACK_IMPORTED_MODULE_148__ = __webpack_require__(6484);
-/* harmony import */ var _src_pro_ndax_js__WEBPACK_IMPORTED_MODULE_149__ = __webpack_require__(8080);
-/* harmony import */ var _src_pro_okcoin_js__WEBPACK_IMPORTED_MODULE_150__ = __webpack_require__(7105);
-/* harmony import */ var _src_pro_okx_js__WEBPACK_IMPORTED_MODULE_151__ = __webpack_require__(2214);
-/* harmony import */ var _src_pro_onetrading_js__WEBPACK_IMPORTED_MODULE_152__ = __webpack_require__(9419);
-/* harmony import */ var _src_pro_p2b_js__WEBPACK_IMPORTED_MODULE_153__ = __webpack_require__(8516);
-/* harmony import */ var _src_pro_phemex_js__WEBPACK_IMPORTED_MODULE_154__ = __webpack_require__(4360);
-/* harmony import */ var _src_pro_poloniex_js__WEBPACK_IMPORTED_MODULE_155__ = __webpack_require__(7924);
-/* harmony import */ var _src_pro_poloniexfutures_js__WEBPACK_IMPORTED_MODULE_156__ = __webpack_require__(3541);
-/* harmony import */ var _src_pro_probit_js__WEBPACK_IMPORTED_MODULE_157__ = __webpack_require__(9782);
-/* harmony import */ var _src_pro_upbit_js__WEBPACK_IMPORTED_MODULE_158__ = __webpack_require__(7614);
-/* harmony import */ var _src_pro_wazirx_js__WEBPACK_IMPORTED_MODULE_159__ = __webpack_require__(4828);
-/* harmony import */ var _src_pro_whitebit_js__WEBPACK_IMPORTED_MODULE_160__ = __webpack_require__(5630);
-/* harmony import */ var _src_pro_woo_js__WEBPACK_IMPORTED_MODULE_161__ = __webpack_require__(3910);
+/* harmony import */ var _src_blofin_js__WEBPACK_IMPORTED_MODULE_33__ = __webpack_require__(687);
+/* harmony import */ var _src_btcalpha_js__WEBPACK_IMPORTED_MODULE_34__ = __webpack_require__(6246);
+/* harmony import */ var _src_btcbox_js__WEBPACK_IMPORTED_MODULE_35__ = __webpack_require__(7796);
+/* harmony import */ var _src_btcmarkets_js__WEBPACK_IMPORTED_MODULE_36__ = __webpack_require__(1776);
+/* harmony import */ var _src_btcturk_js__WEBPACK_IMPORTED_MODULE_37__ = __webpack_require__(6304);
+/* harmony import */ var _src_bybit_js__WEBPACK_IMPORTED_MODULE_38__ = __webpack_require__(3527);
+/* harmony import */ var _src_cex_js__WEBPACK_IMPORTED_MODULE_39__ = __webpack_require__(6445);
+/* harmony import */ var _src_coinbase_js__WEBPACK_IMPORTED_MODULE_40__ = __webpack_require__(437);
+/* harmony import */ var _src_coinbasepro_js__WEBPACK_IMPORTED_MODULE_41__ = __webpack_require__(8856);
+/* harmony import */ var _src_coincheck_js__WEBPACK_IMPORTED_MODULE_42__ = __webpack_require__(2117);
+/* harmony import */ var _src_coinex_js__WEBPACK_IMPORTED_MODULE_43__ = __webpack_require__(332);
+/* harmony import */ var _src_coinlist_js__WEBPACK_IMPORTED_MODULE_44__ = __webpack_require__(3623);
+/* harmony import */ var _src_coinmate_js__WEBPACK_IMPORTED_MODULE_45__ = __webpack_require__(9816);
+/* harmony import */ var _src_coinmetro_js__WEBPACK_IMPORTED_MODULE_46__ = __webpack_require__(4759);
+/* harmony import */ var _src_coinone_js__WEBPACK_IMPORTED_MODULE_47__ = __webpack_require__(7811);
+/* harmony import */ var _src_coinsph_js__WEBPACK_IMPORTED_MODULE_48__ = __webpack_require__(5782);
+/* harmony import */ var _src_coinspot_js__WEBPACK_IMPORTED_MODULE_49__ = __webpack_require__(7794);
+/* harmony import */ var _src_cryptocom_js__WEBPACK_IMPORTED_MODULE_50__ = __webpack_require__(9129);
+/* harmony import */ var _src_currencycom_js__WEBPACK_IMPORTED_MODULE_51__ = __webpack_require__(3214);
+/* harmony import */ var _src_delta_js__WEBPACK_IMPORTED_MODULE_52__ = __webpack_require__(1753);
+/* harmony import */ var _src_deribit_js__WEBPACK_IMPORTED_MODULE_53__ = __webpack_require__(24);
+/* harmony import */ var _src_digifinex_js__WEBPACK_IMPORTED_MODULE_54__ = __webpack_require__(8846);
+/* harmony import */ var _src_exmo_js__WEBPACK_IMPORTED_MODULE_55__ = __webpack_require__(1729);
+/* harmony import */ var _src_fmfwio_js__WEBPACK_IMPORTED_MODULE_56__ = __webpack_require__(5788);
+/* harmony import */ var _src_gate_js__WEBPACK_IMPORTED_MODULE_57__ = __webpack_require__(7290);
+/* harmony import */ var _src_gateio_js__WEBPACK_IMPORTED_MODULE_58__ = __webpack_require__(7036);
+/* harmony import */ var _src_gemini_js__WEBPACK_IMPORTED_MODULE_59__ = __webpack_require__(6743);
+/* harmony import */ var _src_hitbtc_js__WEBPACK_IMPORTED_MODULE_60__ = __webpack_require__(4714);
+/* harmony import */ var _src_hitbtc3_js__WEBPACK_IMPORTED_MODULE_61__ = __webpack_require__(4815);
+/* harmony import */ var _src_hollaex_js__WEBPACK_IMPORTED_MODULE_62__ = __webpack_require__(8422);
+/* harmony import */ var _src_htx_js__WEBPACK_IMPORTED_MODULE_63__ = __webpack_require__(5939);
+/* harmony import */ var _src_huobi_js__WEBPACK_IMPORTED_MODULE_64__ = __webpack_require__(8146);
+/* harmony import */ var _src_huobijp_js__WEBPACK_IMPORTED_MODULE_65__ = __webpack_require__(7034);
+/* harmony import */ var _src_idex_js__WEBPACK_IMPORTED_MODULE_66__ = __webpack_require__(8232);
+/* harmony import */ var _src_independentreserve_js__WEBPACK_IMPORTED_MODULE_67__ = __webpack_require__(9570);
+/* harmony import */ var _src_indodax_js__WEBPACK_IMPORTED_MODULE_68__ = __webpack_require__(1605);
+/* harmony import */ var _src_kraken_js__WEBPACK_IMPORTED_MODULE_69__ = __webpack_require__(9922);
+/* harmony import */ var _src_krakenfutures_js__WEBPACK_IMPORTED_MODULE_70__ = __webpack_require__(4470);
+/* harmony import */ var _src_kucoin_js__WEBPACK_IMPORTED_MODULE_71__ = __webpack_require__(3583);
+/* harmony import */ var _src_kucoinfutures_js__WEBPACK_IMPORTED_MODULE_72__ = __webpack_require__(1924);
+/* harmony import */ var _src_kuna_js__WEBPACK_IMPORTED_MODULE_73__ = __webpack_require__(7732);
+/* harmony import */ var _src_latoken_js__WEBPACK_IMPORTED_MODULE_74__ = __webpack_require__(2545);
+/* harmony import */ var _src_lbank_js__WEBPACK_IMPORTED_MODULE_75__ = __webpack_require__(3944);
+/* harmony import */ var _src_luno_js__WEBPACK_IMPORTED_MODULE_76__ = __webpack_require__(1758);
+/* harmony import */ var _src_lykke_js__WEBPACK_IMPORTED_MODULE_77__ = __webpack_require__(3803);
+/* harmony import */ var _src_mercado_js__WEBPACK_IMPORTED_MODULE_78__ = __webpack_require__(9013);
+/* harmony import */ var _src_mexc_js__WEBPACK_IMPORTED_MODULE_79__ = __webpack_require__(6641);
+/* harmony import */ var _src_ndax_js__WEBPACK_IMPORTED_MODULE_80__ = __webpack_require__(4531);
+/* harmony import */ var _src_novadax_js__WEBPACK_IMPORTED_MODULE_81__ = __webpack_require__(2449);
+/* harmony import */ var _src_oceanex_js__WEBPACK_IMPORTED_MODULE_82__ = __webpack_require__(6749);
+/* harmony import */ var _src_okcoin_js__WEBPACK_IMPORTED_MODULE_83__ = __webpack_require__(3007);
+/* harmony import */ var _src_okx_js__WEBPACK_IMPORTED_MODULE_84__ = __webpack_require__(4042);
+/* harmony import */ var _src_onetrading_js__WEBPACK_IMPORTED_MODULE_85__ = __webpack_require__(6481);
+/* harmony import */ var _src_p2b_js__WEBPACK_IMPORTED_MODULE_86__ = __webpack_require__(2466);
+/* harmony import */ var _src_paymium_js__WEBPACK_IMPORTED_MODULE_87__ = __webpack_require__(7082);
+/* harmony import */ var _src_phemex_js__WEBPACK_IMPORTED_MODULE_88__ = __webpack_require__(79);
+/* harmony import */ var _src_poloniex_js__WEBPACK_IMPORTED_MODULE_89__ = __webpack_require__(8891);
+/* harmony import */ var _src_poloniexfutures_js__WEBPACK_IMPORTED_MODULE_90__ = __webpack_require__(6877);
+/* harmony import */ var _src_probit_js__WEBPACK_IMPORTED_MODULE_91__ = __webpack_require__(3657);
+/* harmony import */ var _src_timex_js__WEBPACK_IMPORTED_MODULE_92__ = __webpack_require__(1067);
+/* harmony import */ var _src_tokocrypto_js__WEBPACK_IMPORTED_MODULE_93__ = __webpack_require__(5261);
+/* harmony import */ var _src_upbit_js__WEBPACK_IMPORTED_MODULE_94__ = __webpack_require__(7584);
+/* harmony import */ var _src_wavesexchange_js__WEBPACK_IMPORTED_MODULE_95__ = __webpack_require__(3853);
+/* harmony import */ var _src_wazirx_js__WEBPACK_IMPORTED_MODULE_96__ = __webpack_require__(6536);
+/* harmony import */ var _src_whitebit_js__WEBPACK_IMPORTED_MODULE_97__ = __webpack_require__(5467);
+/* harmony import */ var _src_woo_js__WEBPACK_IMPORTED_MODULE_98__ = __webpack_require__(517);
+/* harmony import */ var _src_yobit_js__WEBPACK_IMPORTED_MODULE_99__ = __webpack_require__(3850);
+/* harmony import */ var _src_zaif_js__WEBPACK_IMPORTED_MODULE_100__ = __webpack_require__(5934);
+/* harmony import */ var _src_zonda_js__WEBPACK_IMPORTED_MODULE_101__ = __webpack_require__(5140);
+/* harmony import */ var _src_pro_alpaca_js__WEBPACK_IMPORTED_MODULE_102__ = __webpack_require__(2467);
+/* harmony import */ var _src_pro_ascendex_js__WEBPACK_IMPORTED_MODULE_103__ = __webpack_require__(2383);
+/* harmony import */ var _src_pro_bequant_js__WEBPACK_IMPORTED_MODULE_104__ = __webpack_require__(8848);
+/* harmony import */ var _src_pro_binance_js__WEBPACK_IMPORTED_MODULE_105__ = __webpack_require__(8764);
+/* harmony import */ var _src_pro_binancecoinm_js__WEBPACK_IMPORTED_MODULE_106__ = __webpack_require__(5078);
+/* harmony import */ var _src_pro_binanceus_js__WEBPACK_IMPORTED_MODULE_107__ = __webpack_require__(1326);
+/* harmony import */ var _src_pro_binanceusdm_js__WEBPACK_IMPORTED_MODULE_108__ = __webpack_require__(1230);
+/* harmony import */ var _src_pro_bingx_js__WEBPACK_IMPORTED_MODULE_109__ = __webpack_require__(6955);
+/* harmony import */ var _src_pro_bitcoincom_js__WEBPACK_IMPORTED_MODULE_110__ = __webpack_require__(453);
+/* harmony import */ var _src_pro_bitfinex_js__WEBPACK_IMPORTED_MODULE_111__ = __webpack_require__(9772);
+/* harmony import */ var _src_pro_bitfinex2_js__WEBPACK_IMPORTED_MODULE_112__ = __webpack_require__(588);
+/* harmony import */ var _src_pro_bitget_js__WEBPACK_IMPORTED_MODULE_113__ = __webpack_require__(1885);
+/* harmony import */ var _src_pro_bitmart_js__WEBPACK_IMPORTED_MODULE_114__ = __webpack_require__(7504);
+/* harmony import */ var _src_pro_bitmex_js__WEBPACK_IMPORTED_MODULE_115__ = __webpack_require__(2302);
+/* harmony import */ var _src_pro_bitopro_js__WEBPACK_IMPORTED_MODULE_116__ = __webpack_require__(2191);
+/* harmony import */ var _src_pro_bitpanda_js__WEBPACK_IMPORTED_MODULE_117__ = __webpack_require__(1297);
+/* harmony import */ var _src_pro_bitrue_js__WEBPACK_IMPORTED_MODULE_118__ = __webpack_require__(3005);
+/* harmony import */ var _src_pro_bitstamp_js__WEBPACK_IMPORTED_MODULE_119__ = __webpack_require__(2317);
+/* harmony import */ var _src_pro_bitvavo_js__WEBPACK_IMPORTED_MODULE_120__ = __webpack_require__(6977);
+/* harmony import */ var _src_pro_blockchaincom_js__WEBPACK_IMPORTED_MODULE_121__ = __webpack_require__(2519);
+/* harmony import */ var _src_pro_bybit_js__WEBPACK_IMPORTED_MODULE_122__ = __webpack_require__(5030);
+/* harmony import */ var _src_pro_cex_js__WEBPACK_IMPORTED_MODULE_123__ = __webpack_require__(5272);
+/* harmony import */ var _src_pro_coinbase_js__WEBPACK_IMPORTED_MODULE_124__ = __webpack_require__(3414);
+/* harmony import */ var _src_pro_coinbasepro_js__WEBPACK_IMPORTED_MODULE_125__ = __webpack_require__(8368);
+/* harmony import */ var _src_pro_coincheck_js__WEBPACK_IMPORTED_MODULE_126__ = __webpack_require__(7891);
+/* harmony import */ var _src_pro_coinex_js__WEBPACK_IMPORTED_MODULE_127__ = __webpack_require__(204);
+/* harmony import */ var _src_pro_coinone_js__WEBPACK_IMPORTED_MODULE_128__ = __webpack_require__(5208);
+/* harmony import */ var _src_pro_cryptocom_js__WEBPACK_IMPORTED_MODULE_129__ = __webpack_require__(6820);
+/* harmony import */ var _src_pro_currencycom_js__WEBPACK_IMPORTED_MODULE_130__ = __webpack_require__(2952);
+/* harmony import */ var _src_pro_deribit_js__WEBPACK_IMPORTED_MODULE_131__ = __webpack_require__(1788);
+/* harmony import */ var _src_pro_exmo_js__WEBPACK_IMPORTED_MODULE_132__ = __webpack_require__(9004);
+/* harmony import */ var _src_pro_gate_js__WEBPACK_IMPORTED_MODULE_133__ = __webpack_require__(8335);
+/* harmony import */ var _src_pro_gateio_js__WEBPACK_IMPORTED_MODULE_134__ = __webpack_require__(1465);
+/* harmony import */ var _src_pro_gemini_js__WEBPACK_IMPORTED_MODULE_135__ = __webpack_require__(9488);
+/* harmony import */ var _src_pro_hitbtc_js__WEBPACK_IMPORTED_MODULE_136__ = __webpack_require__(5189);
+/* harmony import */ var _src_pro_hollaex_js__WEBPACK_IMPORTED_MODULE_137__ = __webpack_require__(8559);
+/* harmony import */ var _src_pro_htx_js__WEBPACK_IMPORTED_MODULE_138__ = __webpack_require__(7474);
+/* harmony import */ var _src_pro_huobi_js__WEBPACK_IMPORTED_MODULE_139__ = __webpack_require__(8384);
+/* harmony import */ var _src_pro_huobijp_js__WEBPACK_IMPORTED_MODULE_140__ = __webpack_require__(9021);
+/* harmony import */ var _src_pro_idex_js__WEBPACK_IMPORTED_MODULE_141__ = __webpack_require__(3484);
+/* harmony import */ var _src_pro_independentreserve_js__WEBPACK_IMPORTED_MODULE_142__ = __webpack_require__(1311);
+/* harmony import */ var _src_pro_kraken_js__WEBPACK_IMPORTED_MODULE_143__ = __webpack_require__(736);
+/* harmony import */ var _src_pro_krakenfutures_js__WEBPACK_IMPORTED_MODULE_144__ = __webpack_require__(449);
+/* harmony import */ var _src_pro_kucoin_js__WEBPACK_IMPORTED_MODULE_145__ = __webpack_require__(2387);
+/* harmony import */ var _src_pro_kucoinfutures_js__WEBPACK_IMPORTED_MODULE_146__ = __webpack_require__(7181);
+/* harmony import */ var _src_pro_lbank_js__WEBPACK_IMPORTED_MODULE_147__ = __webpack_require__(1267);
+/* harmony import */ var _src_pro_luno_js__WEBPACK_IMPORTED_MODULE_148__ = __webpack_require__(627);
+/* harmony import */ var _src_pro_mexc_js__WEBPACK_IMPORTED_MODULE_149__ = __webpack_require__(6484);
+/* harmony import */ var _src_pro_ndax_js__WEBPACK_IMPORTED_MODULE_150__ = __webpack_require__(8080);
+/* harmony import */ var _src_pro_okcoin_js__WEBPACK_IMPORTED_MODULE_151__ = __webpack_require__(7105);
+/* harmony import */ var _src_pro_okx_js__WEBPACK_IMPORTED_MODULE_152__ = __webpack_require__(2214);
+/* harmony import */ var _src_pro_onetrading_js__WEBPACK_IMPORTED_MODULE_153__ = __webpack_require__(9419);
+/* harmony import */ var _src_pro_p2b_js__WEBPACK_IMPORTED_MODULE_154__ = __webpack_require__(8516);
+/* harmony import */ var _src_pro_phemex_js__WEBPACK_IMPORTED_MODULE_155__ = __webpack_require__(4360);
+/* harmony import */ var _src_pro_poloniex_js__WEBPACK_IMPORTED_MODULE_156__ = __webpack_require__(7924);
+/* harmony import */ var _src_pro_poloniexfutures_js__WEBPACK_IMPORTED_MODULE_157__ = __webpack_require__(3541);
+/* harmony import */ var _src_pro_probit_js__WEBPACK_IMPORTED_MODULE_158__ = __webpack_require__(9782);
+/* harmony import */ var _src_pro_upbit_js__WEBPACK_IMPORTED_MODULE_159__ = __webpack_require__(7614);
+/* harmony import */ var _src_pro_wazirx_js__WEBPACK_IMPORTED_MODULE_160__ = __webpack_require__(4828);
+/* harmony import */ var _src_pro_whitebit_js__WEBPACK_IMPORTED_MODULE_161__ = __webpack_require__(5630);
+/* harmony import */ var _src_pro_woo_js__WEBPACK_IMPORTED_MODULE_162__ = __webpack_require__(3910);
 /*
 
 MIT License
@@ -301952,7 +304136,7 @@ SOFTWARE.
 
 //-----------------------------------------------------------------------------
 // this is updated by vss.js when building
-const version = '4.2.37';
+const version = '4.2.38';
 _src_base_Exchange_js__WEBPACK_IMPORTED_MODULE_0__/* .Exchange */ .e.ccxtVersion = version;
 //-----------------------------------------------------------------------------
 
@@ -302053,6 +304237,7 @@ _src_base_Exchange_js__WEBPACK_IMPORTED_MODULE_0__/* .Exchange */ .e.ccxtVersion
 
 
 
+
 
 
 // pro exchanges
@@ -302150,137 +304335,138 @@ const exchanges = {
     'bitvavo': _src_bitvavo_js__WEBPACK_IMPORTED_MODULE_30__/* ["default"] */ .Z,
     'bl3p': _src_bl3p_js__WEBPACK_IMPORTED_MODULE_31__/* ["default"] */ .Z,
     'blockchaincom': _src_blockchaincom_js__WEBPACK_IMPORTED_MODULE_32__/* ["default"] */ .Z,
-    'btcalpha': _src_btcalpha_js__WEBPACK_IMPORTED_MODULE_33__/* ["default"] */ .Z,
-    'btcbox': _src_btcbox_js__WEBPACK_IMPORTED_MODULE_34__/* ["default"] */ .Z,
-    'btcmarkets': _src_btcmarkets_js__WEBPACK_IMPORTED_MODULE_35__/* ["default"] */ .Z,
-    'btcturk': _src_btcturk_js__WEBPACK_IMPORTED_MODULE_36__/* ["default"] */ .Z,
-    'bybit': _src_bybit_js__WEBPACK_IMPORTED_MODULE_37__/* ["default"] */ .Z,
-    'cex': _src_cex_js__WEBPACK_IMPORTED_MODULE_38__/* ["default"] */ .Z,
-    'coinbase': _src_coinbase_js__WEBPACK_IMPORTED_MODULE_39__/* ["default"] */ .Z,
-    'coinbasepro': _src_coinbasepro_js__WEBPACK_IMPORTED_MODULE_40__/* ["default"] */ .Z,
-    'coincheck': _src_coincheck_js__WEBPACK_IMPORTED_MODULE_41__/* ["default"] */ .Z,
-    'coinex': _src_coinex_js__WEBPACK_IMPORTED_MODULE_42__/* ["default"] */ .Z,
-    'coinlist': _src_coinlist_js__WEBPACK_IMPORTED_MODULE_43__/* ["default"] */ .Z,
-    'coinmate': _src_coinmate_js__WEBPACK_IMPORTED_MODULE_44__/* ["default"] */ .Z,
-    'coinmetro': _src_coinmetro_js__WEBPACK_IMPORTED_MODULE_45__/* ["default"] */ .Z,
-    'coinone': _src_coinone_js__WEBPACK_IMPORTED_MODULE_46__/* ["default"] */ .Z,
-    'coinsph': _src_coinsph_js__WEBPACK_IMPORTED_MODULE_47__/* ["default"] */ .Z,
-    'coinspot': _src_coinspot_js__WEBPACK_IMPORTED_MODULE_48__/* ["default"] */ .Z,
-    'cryptocom': _src_cryptocom_js__WEBPACK_IMPORTED_MODULE_49__/* ["default"] */ .Z,
-    'currencycom': _src_currencycom_js__WEBPACK_IMPORTED_MODULE_50__/* ["default"] */ .Z,
-    'delta': _src_delta_js__WEBPACK_IMPORTED_MODULE_51__/* ["default"] */ .Z,
-    'deribit': _src_deribit_js__WEBPACK_IMPORTED_MODULE_52__/* ["default"] */ .Z,
-    'digifinex': _src_digifinex_js__WEBPACK_IMPORTED_MODULE_53__/* ["default"] */ .Z,
-    'exmo': _src_exmo_js__WEBPACK_IMPORTED_MODULE_54__/* ["default"] */ .Z,
-    'fmfwio': _src_fmfwio_js__WEBPACK_IMPORTED_MODULE_55__/* ["default"] */ .Z,
-    'gate': _src_gate_js__WEBPACK_IMPORTED_MODULE_56__/* ["default"] */ .Z,
-    'gateio': _src_gateio_js__WEBPACK_IMPORTED_MODULE_57__/* ["default"] */ .Z,
-    'gemini': _src_gemini_js__WEBPACK_IMPORTED_MODULE_58__/* ["default"] */ .Z,
-    'hitbtc': _src_hitbtc_js__WEBPACK_IMPORTED_MODULE_59__/* ["default"] */ .Z,
-    'hitbtc3': _src_hitbtc3_js__WEBPACK_IMPORTED_MODULE_60__/* ["default"] */ .Z,
-    'hollaex': _src_hollaex_js__WEBPACK_IMPORTED_MODULE_61__/* ["default"] */ .Z,
-    'htx': _src_htx_js__WEBPACK_IMPORTED_MODULE_62__/* ["default"] */ .Z,
-    'huobi': _src_huobi_js__WEBPACK_IMPORTED_MODULE_63__/* ["default"] */ .Z,
-    'huobijp': _src_huobijp_js__WEBPACK_IMPORTED_MODULE_64__/* ["default"] */ .Z,
-    'idex': _src_idex_js__WEBPACK_IMPORTED_MODULE_65__/* ["default"] */ .Z,
-    'independentreserve': _src_independentreserve_js__WEBPACK_IMPORTED_MODULE_66__/* ["default"] */ .Z,
-    'indodax': _src_indodax_js__WEBPACK_IMPORTED_MODULE_67__/* ["default"] */ .Z,
-    'kraken': _src_kraken_js__WEBPACK_IMPORTED_MODULE_68__/* ["default"] */ .Z,
-    'krakenfutures': _src_krakenfutures_js__WEBPACK_IMPORTED_MODULE_69__/* ["default"] */ .Z,
-    'kucoin': _src_kucoin_js__WEBPACK_IMPORTED_MODULE_70__/* ["default"] */ .Z,
-    'kucoinfutures': _src_kucoinfutures_js__WEBPACK_IMPORTED_MODULE_71__/* ["default"] */ .Z,
-    'kuna': _src_kuna_js__WEBPACK_IMPORTED_MODULE_72__/* ["default"] */ .Z,
-    'latoken': _src_latoken_js__WEBPACK_IMPORTED_MODULE_73__/* ["default"] */ .Z,
-    'lbank': _src_lbank_js__WEBPACK_IMPORTED_MODULE_74__/* ["default"] */ .Z,
-    'luno': _src_luno_js__WEBPACK_IMPORTED_MODULE_75__/* ["default"] */ .Z,
-    'lykke': _src_lykke_js__WEBPACK_IMPORTED_MODULE_76__/* ["default"] */ .Z,
-    'mercado': _src_mercado_js__WEBPACK_IMPORTED_MODULE_77__/* ["default"] */ .Z,
-    'mexc': _src_mexc_js__WEBPACK_IMPORTED_MODULE_78__/* ["default"] */ .Z,
-    'ndax': _src_ndax_js__WEBPACK_IMPORTED_MODULE_79__/* ["default"] */ .Z,
-    'novadax': _src_novadax_js__WEBPACK_IMPORTED_MODULE_80__/* ["default"] */ .Z,
-    'oceanex': _src_oceanex_js__WEBPACK_IMPORTED_MODULE_81__/* ["default"] */ .Z,
-    'okcoin': _src_okcoin_js__WEBPACK_IMPORTED_MODULE_82__/* ["default"] */ .Z,
-    'okx': _src_okx_js__WEBPACK_IMPORTED_MODULE_83__/* ["default"] */ .Z,
-    'onetrading': _src_onetrading_js__WEBPACK_IMPORTED_MODULE_84__/* ["default"] */ .Z,
-    'p2b': _src_p2b_js__WEBPACK_IMPORTED_MODULE_85__/* ["default"] */ .Z,
-    'paymium': _src_paymium_js__WEBPACK_IMPORTED_MODULE_86__/* ["default"] */ .Z,
-    'phemex': _src_phemex_js__WEBPACK_IMPORTED_MODULE_87__/* ["default"] */ .Z,
-    'poloniex': _src_poloniex_js__WEBPACK_IMPORTED_MODULE_88__/* ["default"] */ .Z,
-    'poloniexfutures': _src_poloniexfutures_js__WEBPACK_IMPORTED_MODULE_89__/* ["default"] */ .Z,
-    'probit': _src_probit_js__WEBPACK_IMPORTED_MODULE_90__/* ["default"] */ .Z,
-    'timex': _src_timex_js__WEBPACK_IMPORTED_MODULE_91__/* ["default"] */ .Z,
-    'tokocrypto': _src_tokocrypto_js__WEBPACK_IMPORTED_MODULE_92__/* ["default"] */ .Z,
-    'upbit': _src_upbit_js__WEBPACK_IMPORTED_MODULE_93__/* ["default"] */ .Z,
-    'wavesexchange': _src_wavesexchange_js__WEBPACK_IMPORTED_MODULE_94__/* ["default"] */ .Z,
-    'wazirx': _src_wazirx_js__WEBPACK_IMPORTED_MODULE_95__/* ["default"] */ .Z,
-    'whitebit': _src_whitebit_js__WEBPACK_IMPORTED_MODULE_96__/* ["default"] */ .Z,
-    'woo': _src_woo_js__WEBPACK_IMPORTED_MODULE_97__/* ["default"] */ .Z,
-    'yobit': _src_yobit_js__WEBPACK_IMPORTED_MODULE_98__/* ["default"] */ .Z,
-    'zaif': _src_zaif_js__WEBPACK_IMPORTED_MODULE_99__/* ["default"] */ .Z,
-    'zonda': _src_zonda_js__WEBPACK_IMPORTED_MODULE_100__/* ["default"] */ .Z,
+    'blofin': _src_blofin_js__WEBPACK_IMPORTED_MODULE_33__/* ["default"] */ .Z,
+    'btcalpha': _src_btcalpha_js__WEBPACK_IMPORTED_MODULE_34__/* ["default"] */ .Z,
+    'btcbox': _src_btcbox_js__WEBPACK_IMPORTED_MODULE_35__/* ["default"] */ .Z,
+    'btcmarkets': _src_btcmarkets_js__WEBPACK_IMPORTED_MODULE_36__/* ["default"] */ .Z,
+    'btcturk': _src_btcturk_js__WEBPACK_IMPORTED_MODULE_37__/* ["default"] */ .Z,
+    'bybit': _src_bybit_js__WEBPACK_IMPORTED_MODULE_38__/* ["default"] */ .Z,
+    'cex': _src_cex_js__WEBPACK_IMPORTED_MODULE_39__/* ["default"] */ .Z,
+    'coinbase': _src_coinbase_js__WEBPACK_IMPORTED_MODULE_40__/* ["default"] */ .Z,
+    'coinbasepro': _src_coinbasepro_js__WEBPACK_IMPORTED_MODULE_41__/* ["default"] */ .Z,
+    'coincheck': _src_coincheck_js__WEBPACK_IMPORTED_MODULE_42__/* ["default"] */ .Z,
+    'coinex': _src_coinex_js__WEBPACK_IMPORTED_MODULE_43__/* ["default"] */ .Z,
+    'coinlist': _src_coinlist_js__WEBPACK_IMPORTED_MODULE_44__/* ["default"] */ .Z,
+    'coinmate': _src_coinmate_js__WEBPACK_IMPORTED_MODULE_45__/* ["default"] */ .Z,
+    'coinmetro': _src_coinmetro_js__WEBPACK_IMPORTED_MODULE_46__/* ["default"] */ .Z,
+    'coinone': _src_coinone_js__WEBPACK_IMPORTED_MODULE_47__/* ["default"] */ .Z,
+    'coinsph': _src_coinsph_js__WEBPACK_IMPORTED_MODULE_48__/* ["default"] */ .Z,
+    'coinspot': _src_coinspot_js__WEBPACK_IMPORTED_MODULE_49__/* ["default"] */ .Z,
+    'cryptocom': _src_cryptocom_js__WEBPACK_IMPORTED_MODULE_50__/* ["default"] */ .Z,
+    'currencycom': _src_currencycom_js__WEBPACK_IMPORTED_MODULE_51__/* ["default"] */ .Z,
+    'delta': _src_delta_js__WEBPACK_IMPORTED_MODULE_52__/* ["default"] */ .Z,
+    'deribit': _src_deribit_js__WEBPACK_IMPORTED_MODULE_53__/* ["default"] */ .Z,
+    'digifinex': _src_digifinex_js__WEBPACK_IMPORTED_MODULE_54__/* ["default"] */ .Z,
+    'exmo': _src_exmo_js__WEBPACK_IMPORTED_MODULE_55__/* ["default"] */ .Z,
+    'fmfwio': _src_fmfwio_js__WEBPACK_IMPORTED_MODULE_56__/* ["default"] */ .Z,
+    'gate': _src_gate_js__WEBPACK_IMPORTED_MODULE_57__/* ["default"] */ .Z,
+    'gateio': _src_gateio_js__WEBPACK_IMPORTED_MODULE_58__/* ["default"] */ .Z,
+    'gemini': _src_gemini_js__WEBPACK_IMPORTED_MODULE_59__/* ["default"] */ .Z,
+    'hitbtc': _src_hitbtc_js__WEBPACK_IMPORTED_MODULE_60__/* ["default"] */ .Z,
+    'hitbtc3': _src_hitbtc3_js__WEBPACK_IMPORTED_MODULE_61__/* ["default"] */ .Z,
+    'hollaex': _src_hollaex_js__WEBPACK_IMPORTED_MODULE_62__/* ["default"] */ .Z,
+    'htx': _src_htx_js__WEBPACK_IMPORTED_MODULE_63__/* ["default"] */ .Z,
+    'huobi': _src_huobi_js__WEBPACK_IMPORTED_MODULE_64__/* ["default"] */ .Z,
+    'huobijp': _src_huobijp_js__WEBPACK_IMPORTED_MODULE_65__/* ["default"] */ .Z,
+    'idex': _src_idex_js__WEBPACK_IMPORTED_MODULE_66__/* ["default"] */ .Z,
+    'independentreserve': _src_independentreserve_js__WEBPACK_IMPORTED_MODULE_67__/* ["default"] */ .Z,
+    'indodax': _src_indodax_js__WEBPACK_IMPORTED_MODULE_68__/* ["default"] */ .Z,
+    'kraken': _src_kraken_js__WEBPACK_IMPORTED_MODULE_69__/* ["default"] */ .Z,
+    'krakenfutures': _src_krakenfutures_js__WEBPACK_IMPORTED_MODULE_70__/* ["default"] */ .Z,
+    'kucoin': _src_kucoin_js__WEBPACK_IMPORTED_MODULE_71__/* ["default"] */ .Z,
+    'kucoinfutures': _src_kucoinfutures_js__WEBPACK_IMPORTED_MODULE_72__/* ["default"] */ .Z,
+    'kuna': _src_kuna_js__WEBPACK_IMPORTED_MODULE_73__/* ["default"] */ .Z,
+    'latoken': _src_latoken_js__WEBPACK_IMPORTED_MODULE_74__/* ["default"] */ .Z,
+    'lbank': _src_lbank_js__WEBPACK_IMPORTED_MODULE_75__/* ["default"] */ .Z,
+    'luno': _src_luno_js__WEBPACK_IMPORTED_MODULE_76__/* ["default"] */ .Z,
+    'lykke': _src_lykke_js__WEBPACK_IMPORTED_MODULE_77__/* ["default"] */ .Z,
+    'mercado': _src_mercado_js__WEBPACK_IMPORTED_MODULE_78__/* ["default"] */ .Z,
+    'mexc': _src_mexc_js__WEBPACK_IMPORTED_MODULE_79__/* ["default"] */ .Z,
+    'ndax': _src_ndax_js__WEBPACK_IMPORTED_MODULE_80__/* ["default"] */ .Z,
+    'novadax': _src_novadax_js__WEBPACK_IMPORTED_MODULE_81__/* ["default"] */ .Z,
+    'oceanex': _src_oceanex_js__WEBPACK_IMPORTED_MODULE_82__/* ["default"] */ .Z,
+    'okcoin': _src_okcoin_js__WEBPACK_IMPORTED_MODULE_83__/* ["default"] */ .Z,
+    'okx': _src_okx_js__WEBPACK_IMPORTED_MODULE_84__/* ["default"] */ .Z,
+    'onetrading': _src_onetrading_js__WEBPACK_IMPORTED_MODULE_85__/* ["default"] */ .Z,
+    'p2b': _src_p2b_js__WEBPACK_IMPORTED_MODULE_86__/* ["default"] */ .Z,
+    'paymium': _src_paymium_js__WEBPACK_IMPORTED_MODULE_87__/* ["default"] */ .Z,
+    'phemex': _src_phemex_js__WEBPACK_IMPORTED_MODULE_88__/* ["default"] */ .Z,
+    'poloniex': _src_poloniex_js__WEBPACK_IMPORTED_MODULE_89__/* ["default"] */ .Z,
+    'poloniexfutures': _src_poloniexfutures_js__WEBPACK_IMPORTED_MODULE_90__/* ["default"] */ .Z,
+    'probit': _src_probit_js__WEBPACK_IMPORTED_MODULE_91__/* ["default"] */ .Z,
+    'timex': _src_timex_js__WEBPACK_IMPORTED_MODULE_92__/* ["default"] */ .Z,
+    'tokocrypto': _src_tokocrypto_js__WEBPACK_IMPORTED_MODULE_93__/* ["default"] */ .Z,
+    'upbit': _src_upbit_js__WEBPACK_IMPORTED_MODULE_94__/* ["default"] */ .Z,
+    'wavesexchange': _src_wavesexchange_js__WEBPACK_IMPORTED_MODULE_95__/* ["default"] */ .Z,
+    'wazirx': _src_wazirx_js__WEBPACK_IMPORTED_MODULE_96__/* ["default"] */ .Z,
+    'whitebit': _src_whitebit_js__WEBPACK_IMPORTED_MODULE_97__/* ["default"] */ .Z,
+    'woo': _src_woo_js__WEBPACK_IMPORTED_MODULE_98__/* ["default"] */ .Z,
+    'yobit': _src_yobit_js__WEBPACK_IMPORTED_MODULE_99__/* ["default"] */ .Z,
+    'zaif': _src_zaif_js__WEBPACK_IMPORTED_MODULE_100__/* ["default"] */ .Z,
+    'zonda': _src_zonda_js__WEBPACK_IMPORTED_MODULE_101__/* ["default"] */ .Z,
 };
 const pro = {
-    'alpaca': _src_pro_alpaca_js__WEBPACK_IMPORTED_MODULE_101__/* ["default"] */ .Z,
-    'ascendex': _src_pro_ascendex_js__WEBPACK_IMPORTED_MODULE_102__/* ["default"] */ .Z,
-    'bequant': _src_pro_bequant_js__WEBPACK_IMPORTED_MODULE_103__/* ["default"] */ .Z,
-    'binance': _src_pro_binance_js__WEBPACK_IMPORTED_MODULE_104__/* ["default"] */ .Z,
-    'binancecoinm': _src_pro_binancecoinm_js__WEBPACK_IMPORTED_MODULE_105__/* ["default"] */ .Z,
-    'binanceus': _src_pro_binanceus_js__WEBPACK_IMPORTED_MODULE_106__/* ["default"] */ .Z,
-    'binanceusdm': _src_pro_binanceusdm_js__WEBPACK_IMPORTED_MODULE_107__/* ["default"] */ .Z,
-    'bingx': _src_pro_bingx_js__WEBPACK_IMPORTED_MODULE_108__/* ["default"] */ .Z,
-    'bitcoincom': _src_pro_bitcoincom_js__WEBPACK_IMPORTED_MODULE_109__/* ["default"] */ .Z,
-    'bitfinex': _src_pro_bitfinex_js__WEBPACK_IMPORTED_MODULE_110__/* ["default"] */ .Z,
-    'bitfinex2': _src_pro_bitfinex2_js__WEBPACK_IMPORTED_MODULE_111__/* ["default"] */ .Z,
-    'bitget': _src_pro_bitget_js__WEBPACK_IMPORTED_MODULE_112__/* ["default"] */ .Z,
-    'bitmart': _src_pro_bitmart_js__WEBPACK_IMPORTED_MODULE_113__/* ["default"] */ .Z,
-    'bitmex': _src_pro_bitmex_js__WEBPACK_IMPORTED_MODULE_114__/* ["default"] */ .Z,
-    'bitopro': _src_pro_bitopro_js__WEBPACK_IMPORTED_MODULE_115__/* ["default"] */ .Z,
-    'bitpanda': _src_pro_bitpanda_js__WEBPACK_IMPORTED_MODULE_116__/* ["default"] */ .Z,
-    'bitrue': _src_pro_bitrue_js__WEBPACK_IMPORTED_MODULE_117__/* ["default"] */ .Z,
-    'bitstamp': _src_pro_bitstamp_js__WEBPACK_IMPORTED_MODULE_118__/* ["default"] */ .Z,
-    'bitvavo': _src_pro_bitvavo_js__WEBPACK_IMPORTED_MODULE_119__/* ["default"] */ .Z,
-    'blockchaincom': _src_pro_blockchaincom_js__WEBPACK_IMPORTED_MODULE_120__/* ["default"] */ .Z,
-    'bybit': _src_pro_bybit_js__WEBPACK_IMPORTED_MODULE_121__/* ["default"] */ .Z,
-    'cex': _src_pro_cex_js__WEBPACK_IMPORTED_MODULE_122__/* ["default"] */ .Z,
-    'coinbase': _src_pro_coinbase_js__WEBPACK_IMPORTED_MODULE_123__/* ["default"] */ .Z,
-    'coinbasepro': _src_pro_coinbasepro_js__WEBPACK_IMPORTED_MODULE_124__/* ["default"] */ .Z,
-    'coincheck': _src_pro_coincheck_js__WEBPACK_IMPORTED_MODULE_125__/* ["default"] */ .Z,
-    'coinex': _src_pro_coinex_js__WEBPACK_IMPORTED_MODULE_126__/* ["default"] */ .Z,
-    'coinone': _src_pro_coinone_js__WEBPACK_IMPORTED_MODULE_127__/* ["default"] */ .Z,
-    'cryptocom': _src_pro_cryptocom_js__WEBPACK_IMPORTED_MODULE_128__/* ["default"] */ .Z,
-    'currencycom': _src_pro_currencycom_js__WEBPACK_IMPORTED_MODULE_129__/* ["default"] */ .Z,
-    'deribit': _src_pro_deribit_js__WEBPACK_IMPORTED_MODULE_130__/* ["default"] */ .Z,
-    'exmo': _src_pro_exmo_js__WEBPACK_IMPORTED_MODULE_131__/* ["default"] */ .Z,
-    'gate': _src_pro_gate_js__WEBPACK_IMPORTED_MODULE_132__/* ["default"] */ .Z,
-    'gateio': _src_pro_gateio_js__WEBPACK_IMPORTED_MODULE_133__/* ["default"] */ .Z,
-    'gemini': _src_pro_gemini_js__WEBPACK_IMPORTED_MODULE_134__/* ["default"] */ .Z,
-    'hitbtc': _src_pro_hitbtc_js__WEBPACK_IMPORTED_MODULE_135__/* ["default"] */ .Z,
-    'hollaex': _src_pro_hollaex_js__WEBPACK_IMPORTED_MODULE_136__/* ["default"] */ .Z,
-    'htx': _src_pro_htx_js__WEBPACK_IMPORTED_MODULE_137__/* ["default"] */ .Z,
-    'huobi': _src_pro_huobi_js__WEBPACK_IMPORTED_MODULE_138__/* ["default"] */ .Z,
-    'huobijp': _src_pro_huobijp_js__WEBPACK_IMPORTED_MODULE_139__/* ["default"] */ .Z,
-    'idex': _src_pro_idex_js__WEBPACK_IMPORTED_MODULE_140__/* ["default"] */ .Z,
-    'independentreserve': _src_pro_independentreserve_js__WEBPACK_IMPORTED_MODULE_141__/* ["default"] */ .Z,
-    'kraken': _src_pro_kraken_js__WEBPACK_IMPORTED_MODULE_142__/* ["default"] */ .Z,
-    'krakenfutures': _src_pro_krakenfutures_js__WEBPACK_IMPORTED_MODULE_143__/* ["default"] */ .Z,
-    'kucoin': _src_pro_kucoin_js__WEBPACK_IMPORTED_MODULE_144__/* ["default"] */ .Z,
-    'kucoinfutures': _src_pro_kucoinfutures_js__WEBPACK_IMPORTED_MODULE_145__/* ["default"] */ .Z,
-    'lbank': _src_pro_lbank_js__WEBPACK_IMPORTED_MODULE_146__/* ["default"] */ .Z,
-    'luno': _src_pro_luno_js__WEBPACK_IMPORTED_MODULE_147__/* ["default"] */ .Z,
-    'mexc': _src_pro_mexc_js__WEBPACK_IMPORTED_MODULE_148__/* ["default"] */ .Z,
-    'ndax': _src_pro_ndax_js__WEBPACK_IMPORTED_MODULE_149__/* ["default"] */ .Z,
-    'okcoin': _src_pro_okcoin_js__WEBPACK_IMPORTED_MODULE_150__/* ["default"] */ .Z,
-    'okx': _src_pro_okx_js__WEBPACK_IMPORTED_MODULE_151__/* ["default"] */ .Z,
-    'onetrading': _src_pro_onetrading_js__WEBPACK_IMPORTED_MODULE_152__/* ["default"] */ .Z,
-    'p2b': _src_pro_p2b_js__WEBPACK_IMPORTED_MODULE_153__/* ["default"] */ .Z,
-    'phemex': _src_pro_phemex_js__WEBPACK_IMPORTED_MODULE_154__/* ["default"] */ .Z,
-    'poloniex': _src_pro_poloniex_js__WEBPACK_IMPORTED_MODULE_155__/* ["default"] */ .Z,
-    'poloniexfutures': _src_pro_poloniexfutures_js__WEBPACK_IMPORTED_MODULE_156__/* ["default"] */ .Z,
-    'probit': _src_pro_probit_js__WEBPACK_IMPORTED_MODULE_157__/* ["default"] */ .Z,
-    'upbit': _src_pro_upbit_js__WEBPACK_IMPORTED_MODULE_158__/* ["default"] */ .Z,
-    'wazirx': _src_pro_wazirx_js__WEBPACK_IMPORTED_MODULE_159__/* ["default"] */ .Z,
-    'whitebit': _src_pro_whitebit_js__WEBPACK_IMPORTED_MODULE_160__/* ["default"] */ .Z,
-    'woo': _src_pro_woo_js__WEBPACK_IMPORTED_MODULE_161__/* ["default"] */ .Z,
+    'alpaca': _src_pro_alpaca_js__WEBPACK_IMPORTED_MODULE_102__/* ["default"] */ .Z,
+    'ascendex': _src_pro_ascendex_js__WEBPACK_IMPORTED_MODULE_103__/* ["default"] */ .Z,
+    'bequant': _src_pro_bequant_js__WEBPACK_IMPORTED_MODULE_104__/* ["default"] */ .Z,
+    'binance': _src_pro_binance_js__WEBPACK_IMPORTED_MODULE_105__/* ["default"] */ .Z,
+    'binancecoinm': _src_pro_binancecoinm_js__WEBPACK_IMPORTED_MODULE_106__/* ["default"] */ .Z,
+    'binanceus': _src_pro_binanceus_js__WEBPACK_IMPORTED_MODULE_107__/* ["default"] */ .Z,
+    'binanceusdm': _src_pro_binanceusdm_js__WEBPACK_IMPORTED_MODULE_108__/* ["default"] */ .Z,
+    'bingx': _src_pro_bingx_js__WEBPACK_IMPORTED_MODULE_109__/* ["default"] */ .Z,
+    'bitcoincom': _src_pro_bitcoincom_js__WEBPACK_IMPORTED_MODULE_110__/* ["default"] */ .Z,
+    'bitfinex': _src_pro_bitfinex_js__WEBPACK_IMPORTED_MODULE_111__/* ["default"] */ .Z,
+    'bitfinex2': _src_pro_bitfinex2_js__WEBPACK_IMPORTED_MODULE_112__/* ["default"] */ .Z,
+    'bitget': _src_pro_bitget_js__WEBPACK_IMPORTED_MODULE_113__/* ["default"] */ .Z,
+    'bitmart': _src_pro_bitmart_js__WEBPACK_IMPORTED_MODULE_114__/* ["default"] */ .Z,
+    'bitmex': _src_pro_bitmex_js__WEBPACK_IMPORTED_MODULE_115__/* ["default"] */ .Z,
+    'bitopro': _src_pro_bitopro_js__WEBPACK_IMPORTED_MODULE_116__/* ["default"] */ .Z,
+    'bitpanda': _src_pro_bitpanda_js__WEBPACK_IMPORTED_MODULE_117__/* ["default"] */ .Z,
+    'bitrue': _src_pro_bitrue_js__WEBPACK_IMPORTED_MODULE_118__/* ["default"] */ .Z,
+    'bitstamp': _src_pro_bitstamp_js__WEBPACK_IMPORTED_MODULE_119__/* ["default"] */ .Z,
+    'bitvavo': _src_pro_bitvavo_js__WEBPACK_IMPORTED_MODULE_120__/* ["default"] */ .Z,
+    'blockchaincom': _src_pro_blockchaincom_js__WEBPACK_IMPORTED_MODULE_121__/* ["default"] */ .Z,
+    'bybit': _src_pro_bybit_js__WEBPACK_IMPORTED_MODULE_122__/* ["default"] */ .Z,
+    'cex': _src_pro_cex_js__WEBPACK_IMPORTED_MODULE_123__/* ["default"] */ .Z,
+    'coinbase': _src_pro_coinbase_js__WEBPACK_IMPORTED_MODULE_124__/* ["default"] */ .Z,
+    'coinbasepro': _src_pro_coinbasepro_js__WEBPACK_IMPORTED_MODULE_125__/* ["default"] */ .Z,
+    'coincheck': _src_pro_coincheck_js__WEBPACK_IMPORTED_MODULE_126__/* ["default"] */ .Z,
+    'coinex': _src_pro_coinex_js__WEBPACK_IMPORTED_MODULE_127__/* ["default"] */ .Z,
+    'coinone': _src_pro_coinone_js__WEBPACK_IMPORTED_MODULE_128__/* ["default"] */ .Z,
+    'cryptocom': _src_pro_cryptocom_js__WEBPACK_IMPORTED_MODULE_129__/* ["default"] */ .Z,
+    'currencycom': _src_pro_currencycom_js__WEBPACK_IMPORTED_MODULE_130__/* ["default"] */ .Z,
+    'deribit': _src_pro_deribit_js__WEBPACK_IMPORTED_MODULE_131__/* ["default"] */ .Z,
+    'exmo': _src_pro_exmo_js__WEBPACK_IMPORTED_MODULE_132__/* ["default"] */ .Z,
+    'gate': _src_pro_gate_js__WEBPACK_IMPORTED_MODULE_133__/* ["default"] */ .Z,
+    'gateio': _src_pro_gateio_js__WEBPACK_IMPORTED_MODULE_134__/* ["default"] */ .Z,
+    'gemini': _src_pro_gemini_js__WEBPACK_IMPORTED_MODULE_135__/* ["default"] */ .Z,
+    'hitbtc': _src_pro_hitbtc_js__WEBPACK_IMPORTED_MODULE_136__/* ["default"] */ .Z,
+    'hollaex': _src_pro_hollaex_js__WEBPACK_IMPORTED_MODULE_137__/* ["default"] */ .Z,
+    'htx': _src_pro_htx_js__WEBPACK_IMPORTED_MODULE_138__/* ["default"] */ .Z,
+    'huobi': _src_pro_huobi_js__WEBPACK_IMPORTED_MODULE_139__/* ["default"] */ .Z,
+    'huobijp': _src_pro_huobijp_js__WEBPACK_IMPORTED_MODULE_140__/* ["default"] */ .Z,
+    'idex': _src_pro_idex_js__WEBPACK_IMPORTED_MODULE_141__/* ["default"] */ .Z,
+    'independentreserve': _src_pro_independentreserve_js__WEBPACK_IMPORTED_MODULE_142__/* ["default"] */ .Z,
+    'kraken': _src_pro_kraken_js__WEBPACK_IMPORTED_MODULE_143__/* ["default"] */ .Z,
+    'krakenfutures': _src_pro_krakenfutures_js__WEBPACK_IMPORTED_MODULE_144__/* ["default"] */ .Z,
+    'kucoin': _src_pro_kucoin_js__WEBPACK_IMPORTED_MODULE_145__/* ["default"] */ .Z,
+    'kucoinfutures': _src_pro_kucoinfutures_js__WEBPACK_IMPORTED_MODULE_146__/* ["default"] */ .Z,
+    'lbank': _src_pro_lbank_js__WEBPACK_IMPORTED_MODULE_147__/* ["default"] */ .Z,
+    'luno': _src_pro_luno_js__WEBPACK_IMPORTED_MODULE_148__/* ["default"] */ .Z,
+    'mexc': _src_pro_mexc_js__WEBPACK_IMPORTED_MODULE_149__/* ["default"] */ .Z,
+    'ndax': _src_pro_ndax_js__WEBPACK_IMPORTED_MODULE_150__/* ["default"] */ .Z,
+    'okcoin': _src_pro_okcoin_js__WEBPACK_IMPORTED_MODULE_151__/* ["default"] */ .Z,
+    'okx': _src_pro_okx_js__WEBPACK_IMPORTED_MODULE_152__/* ["default"] */ .Z,
+    'onetrading': _src_pro_onetrading_js__WEBPACK_IMPORTED_MODULE_153__/* ["default"] */ .Z,
+    'p2b': _src_pro_p2b_js__WEBPACK_IMPORTED_MODULE_154__/* ["default"] */ .Z,
+    'phemex': _src_pro_phemex_js__WEBPACK_IMPORTED_MODULE_155__/* ["default"] */ .Z,
+    'poloniex': _src_pro_poloniex_js__WEBPACK_IMPORTED_MODULE_156__/* ["default"] */ .Z,
+    'poloniexfutures': _src_pro_poloniexfutures_js__WEBPACK_IMPORTED_MODULE_157__/* ["default"] */ .Z,
+    'probit': _src_pro_probit_js__WEBPACK_IMPORTED_MODULE_158__/* ["default"] */ .Z,
+    'upbit': _src_pro_upbit_js__WEBPACK_IMPORTED_MODULE_159__/* ["default"] */ .Z,
+    'wazirx': _src_pro_wazirx_js__WEBPACK_IMPORTED_MODULE_160__/* ["default"] */ .Z,
+    'whitebit': _src_pro_whitebit_js__WEBPACK_IMPORTED_MODULE_161__/* ["default"] */ .Z,
+    'woo': _src_pro_woo_js__WEBPACK_IMPORTED_MODULE_162__/* ["default"] */ .Z,
 };
 for (const exchange in pro) {
     // const ccxtExchange = exchanges[exchange]
@@ -302293,7 +304479,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_162__/* .Precise */ .O, 'exchanges': Object.keys(exchanges), 'pro': pro }, exchanges, _src_base_functions_js__WEBPACK_IMPORTED_MODULE_163__, _src_base_errors_js__WEBPACK_IMPORTED_MODULE_164__);
+const ccxt = Object.assign({ version, Exchange: _src_base_Exchange_js__WEBPACK_IMPORTED_MODULE_0__/* .Exchange */ .e, Precise: _src_base_Precise_js__WEBPACK_IMPORTED_MODULE_163__/* .Precise */ .O, 'exchanges': Object.keys(exchanges), 'pro': pro }, exchanges, _src_base_functions_js__WEBPACK_IMPORTED_MODULE_164__, _src_base_errors_js__WEBPACK_IMPORTED_MODULE_165__);
 
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (ccxt);
 //-----------------------------------------------------------------------------