ccxt 4.1.41 → 4.1.43

package/dist/ccxt.browser.js

@@ -624,6 +624,22 @@ class Exchange extends _base_Exchange_js__WEBPACK_IMPORTED_MODULE_0__/* .Exchang
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Exchange);
 
 
+/***/ }),
+
+/***/ 3378:
+/***/ ((__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);
+
+
 /***/ }),
 
 /***/ 7044:
@@ -3416,6 +3432,7 @@ class ascendex extends _abstract_ascendex_js__WEBPACK_IMPORTED_MODULE_0__/* ["de
                 'cancelAllOrders': true,
                 'cancelOrder': true,
                 'createOrder': true,
+                'createOrders': true,
                 'createPostOnlyOrder': true,
                 'createReduceOnlyOrder': true,
                 'createStopLimitOrder': true,
@@ -4841,30 +4858,33 @@ class ascendex extends _abstract_ascendex_js__WEBPACK_IMPORTED_MODULE_0__/* ["de
         }
         return result;
     }
-    async createOrder(symbol, type, side, amount, price = undefined, params = {}) {
+    createOrderRequest(symbol, type, side, amount, price = undefined, params = {}) {
         /**
          * @method
-         * @name ascendex#createOrder
-         * @description Create an order on the exchange
-         * @param {string} symbol Unified CCXT market symbol
-         * @param {string} type "limit" or "market"
-         * @param {string} side "buy" or "sell"
-         * @param {float} amount the amount of currency to trade
-         * @param {float} [price] *ignored in "market" orders* the price at which the order is to be fullfilled at in units of the quote currency
-         * @param {object} [params] Extra parameters specific to the exchange API endpoint
+         * @ignore
+         * @name ascendex#createOrderRequest
+         * @description helper function to build request
+         * @param {string} symbol unified symbol of the market to create an order in
+         * @param {string} type 'market' or 'limit'
+         * @param {string} side 'buy' or 'sell'
+         * @param {float} amount how much you want to trade in units of the 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 ascendex api endpoint
          * @param {string} [params.timeInForce] "GTC", "IOC", "FOK", or "PO"
          * @param {bool} [params.postOnly] true or false
-         * @param {float} [params.stopPrice] The price at which a trigger order is triggered at
-         * @returns [An order structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
+         * @param {float} [params.stopPrice] the price at which a trigger order is triggered at
+         * @returns {object} request to be sent to the exchange
          */
-        await this.loadMarkets();
-        await this.loadAccounts();
         const market = this.market(symbol);
+        let marginMode = undefined;
         let marketType = undefined;
-        [marketType, params] = this.handleMarketTypeAndParams('createOrder', market, params);
-        const options = this.safeValue(this.options, 'createOrder', {});
+        [marginMode, params] = this.handleMarginModeAndParams('createOrderRequest', params);
+        [marketType, params] = this.handleMarketTypeAndParams('createOrderRequest', market, params);
         const accountsByType = this.safeValue(this.options, 'accountsByType', {});
-        const accountCategory = this.safeString(accountsByType, marketType, 'cash');
+        let accountCategory = this.safeString(accountsByType, marketType, 'cash');
+        if (marginMode !== undefined) {
+            accountCategory = 'margin';
+        }
         const account = this.safeValue(this.accounts, 0, {});
         const accountGroup = this.safeValue(account, 'id');
         const clientOrderId = this.safeString2(params, 'clientOrderId', 'id');
@@ -4885,13 +4905,6 @@ class ascendex extends _abstract_ascendex_js__WEBPACK_IMPORTED_MODULE_0__/* ["de
         const postOnly = this.isPostOnly(isMarketOrder, false, params);
         const reduceOnly = this.safeValue(params, 'reduceOnly', false);
         const stopPrice = this.safeValue2(params, 'triggerPrice', 'stopPrice');
-        params = this.omit(params, ['timeInForce', 'postOnly', 'reduceOnly', 'stopPrice', 'triggerPrice']);
-        if (reduceOnly) {
-            if (marketType !== 'swap') {
-                throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.InvalidOrder(this.id + ' createOrder() does not support reduceOnly for ' + marketType + ' orders, reduceOnly orders are supported for perpetuals only');
-            }
-            request['execInst'] = 'ReduceOnly';
-        }
         if (isLimitOrder) {
             request['orderPrice'] = this.priceToPrecision(symbol, price);
         }
@@ -4916,21 +4929,56 @@ class ascendex extends _abstract_ascendex_js__WEBPACK_IMPORTED_MODULE_0__/* ["de
         if (clientOrderId !== undefined) {
             request['id'] = clientOrderId;
         }
-        const defaultMethod = this.safeString(options, 'method', 'v1PrivateAccountCategoryPostOrder');
-        const method = this.getSupportedMapping(marketType, {
-            'spot': defaultMethod,
-            'margin': defaultMethod,
-            'swap': 'v2PrivateAccountGroupPostFuturesOrder',
-        });
-        if (method === 'v1PrivateAccountCategoryPostOrder') {
+        if (market['spot']) {
             if (accountCategory !== undefined) {
                 request['category'] = accountCategory;
             }
         }
         else {
             request['account-category'] = accountCategory;
+            if (reduceOnly) {
+                request['execInst'] = 'ReduceOnly';
+            }
+            if (postOnly) {
+                request['execInst'] = 'Post';
+            }
+        }
+        params = this.omit(params, ['reduceOnly', 'triggerPrice']);
+        return this.extend(request, params);
+    }
+    async createOrder(symbol, type, side, amount, price = undefined, params = {}) {
+        /**
+         * @method
+         * @name ascendex#createOrder
+         * @description create a trade order on the exchange
+         * @see https://ascendex.github.io/ascendex-pro-api/#place-order
+         * @see https://ascendex.github.io/ascendex-futures-pro-api-v2/#new-order
+         * @param {string} symbol unified CCXT market symbol
+         * @param {string} type "limit" or "market"
+         * @param {string} side "buy" or "sell"
+         * @param {float} amount the amount of currency to trade
+         * @param {float} [price] *ignored in "market" orders* the price at which the order is to be fullfilled at in units of the quote currency
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {string} [params.timeInForce] "GTC", "IOC", "FOK", or "PO"
+         * @param {bool} [params.postOnly] true or false
+         * @param {float} [params.stopPrice] the price at which a trigger order is triggered at
+         * @param {object} [params.takeProfit] *takeProfit object in params* containing the triggerPrice that the attached take profit order will be triggered (perpetual swap markets only)
+         * @param {float} [params.takeProfit.triggerPrice] *swap only* take profit trigger price
+         * @param {object} [params.stopLoss] *stopLoss object in params* containing the triggerPrice that the attached stop loss order will be triggered (perpetual swap markets only)
+         * @param {float} [params.stopLoss.triggerPrice] *swap only* stop loss trigger price
+         * @returns [An order structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
+         */
+        await this.loadMarkets();
+        await this.loadAccounts();
+        const market = this.market(symbol);
+        const request = this.createOrderRequest(symbol, type, side, amount, price, params);
+        let response = undefined;
+        if (market['swap']) {
+            response = await this.v2PrivateAccountGroupPostFuturesOrder(request);
+        }
+        else {
+            response = await this.v1PrivateAccountCategoryPostOrder(request);
         }
-        const response = await this[method](this.extend(request, params));
         //
         // spot
         //
@@ -4951,7 +4999,6 @@ class ascendex extends _abstract_ascendex_js__WEBPACK_IMPORTED_MODULE_0__/* ["de
         //          }
         //      }
         //
-        //
         // swap
         //
         //      {
@@ -4999,6 +5046,105 @@ class ascendex extends _abstract_ascendex_js__WEBPACK_IMPORTED_MODULE_0__/* ["de
         const order = this.safeValue2(data, 'order', 'info', {});
         return this.parseOrder(order, market);
     }
+    async createOrders(orders, params = {}) {
+        /**
+         * @method
+         * @name ascendex#createOrders
+         * @description create a list of trade orders
+         * @see https://ascendex.github.io/ascendex-pro-api/#place-batch-orders
+         * @see https://ascendex.github.io/ascendex-futures-pro-api-v2/#place-batch-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
+         * @param {object} [params] extra parameters specific to the ascendex api endpoint
+         * @param {string} [params.timeInForce] "GTC", "IOC", "FOK", or "PO"
+         * @param {bool} [params.postOnly] true or false
+         * @param {float} [params.stopPrice] the price at which a trigger order is triggered at
+         * @returns {object} an [order structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
+         */
+        await this.loadMarkets();
+        await this.loadAccounts();
+        const ordersRequests = [];
+        let symbol = undefined;
+        let marginMode = undefined;
+        for (let i = 0; i < orders.length; i++) {
+            const rawOrder = orders[i];
+            const marketId = this.safeString(rawOrder, 'symbol');
+            if (symbol === undefined) {
+                symbol = marketId;
+            }
+            else {
+                if (symbol !== marketId) {
+                    throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.BadRequest(this.id + ' createOrders() requires all orders to have the same 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 marginResult = this.handleMarginModeAndParams('createOrders', orderParams);
+            const currentMarginMode = marginResult[0];
+            if (currentMarginMode !== undefined) {
+                if (marginMode === undefined) {
+                    marginMode = currentMarginMode;
+                }
+                else {
+                    if (marginMode !== currentMarginMode) {
+                        throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.BadRequest(this.id + ' createOrders() requires all orders to have the same margin mode (isolated or cross)');
+                    }
+                }
+            }
+            const orderRequest = this.createOrderRequest(marketId, type, side, amount, price, orderParams);
+            ordersRequests.push(orderRequest);
+        }
+        const market = this.market(symbol);
+        const accountsByType = this.safeValue(this.options, 'accountsByType', {});
+        let accountCategory = this.safeString(accountsByType, market['type'], 'cash');
+        if (marginMode !== undefined) {
+            accountCategory = 'margin';
+        }
+        const account = this.safeValue(this.accounts, 0, {});
+        const accountGroup = this.safeValue(account, 'id');
+        const request = {};
+        let response = undefined;
+        if (market['swap']) {
+            throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.NotSupported(this.id + ' createOrders() is not currently supported for swap markets on ascendex');
+            // request['account-group'] = accountGroup;
+            // request['category'] = accountCategory;
+            // request['orders'] = ordersRequests;
+            // response = await this.v2PrivateAccountGroupPostFuturesOrderBatch (request);
+        }
+        else {
+            request['account-group'] = accountGroup;
+            request['account-category'] = accountCategory;
+            request['orders'] = ordersRequests;
+            response = await this.v1PrivateAccountCategoryPostOrderBatch(request);
+        }
+        //
+        // spot
+        //
+        //     {
+        //         "code": 0,
+        //         "data": {
+        //             "accountId": "cshdAKBO43TKIh2kJtq7FVVb42KIePyS",
+        //             "ac": "CASH",
+        //             "action": "batch-place-order",
+        //             "status": "Ack",
+        //             "info": [
+        //                 {
+        //                     "symbol": "BTC/USDT",
+        //                     "orderType": "Limit",
+        //                     "timestamp": 1699326589344,
+        //                     "id": "",
+        //                     "orderId": "a18ba7c1f6efU0711043490p3HvjjN5x"
+        //                 }
+        //             ]
+        //         }
+        //     }
+        //
+        const data = this.safeValue(response, 'data', {});
+        const info = this.safeValue(data, 'info', []);
+        return this.parseOrders(info, market);
+    }
     async fetchOrder(id, symbol = undefined, params = {}) {
         /**
          * @method
@@ -95393,6 +95539,2343 @@ class coinfalcon extends _abstract_coinfalcon_js__WEBPACK_IMPORTED_MODULE_0__/*
 }
 
 
+/***/ }),
+
+/***/ 3623:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "Z": () => (/* binding */ coinlist)
+/* harmony export */ });
+/* harmony import */ var _abstract_coinlist_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3378);
+/* harmony import */ var _base_errors_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6689);
+/* harmony import */ var _base_functions_number_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(9292);
+/* harmony import */ var _base_Precise_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(2194);
+/* harmony import */ var _static_dependencies_noble_hashes_sha256_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(1372);
+
+
+
+
+
+/**
+ * @class coinlist
+ * @extends Exchange
+ */
+class coinlist extends _abstract_coinlist_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z {
+    describe() {
+        return this.deepExtend(super.describe(), {
+            'id': 'coinlist',
+            'name': 'Coinlist',
+            'countries': ['US'],
+            'version': 'v1',
+            'rateLimit': 300,
+            'certified': false,
+            'pro': false,
+            'has': {
+                'CORS': undefined,
+                'spot': true,
+                'margin': false,
+                'swap': false,
+                'future': false,
+                'option': false,
+                'addMargin': false,
+                'borrowMargin': false,
+                'cancelAllOrders': true,
+                'cancelOrder': true,
+                'cancelOrders': true,
+                'createDepositAddress': false,
+                'createOrder': true,
+                'createPostOnlyOrder': true,
+                'createReduceOnlyOrder': false,
+                'createStopLimitOrder': true,
+                'createStopMarketOrder': true,
+                'createStopOrder': true,
+                'deposit': false,
+                'editOrder': true,
+                'fetchAccounts': true,
+                'fetchBalance': true,
+                'fetchBidsAsks': false,
+                'fetchBorrowInterest': false,
+                'fetchBorrowRate': false,
+                'fetchBorrowRateHistories': false,
+                'fetchBorrowRateHistory': false,
+                'fetchBorrowRates': false,
+                'fetchBorrowRatesPerSymbol': false,
+                'fetchCanceledOrders': true,
+                'fetchClosedOrder': false,
+                'fetchClosedOrders': true,
+                'fetchCurrencies': true,
+                'fetchDeposit': false,
+                'fetchDepositAddress': false,
+                'fetchDepositAddresses': false,
+                'fetchDepositAddressesByNetwork': false,
+                'fetchDeposits': false,
+                'fetchDepositsWithdrawals': true,
+                'fetchDepositWithdrawFee': false,
+                'fetchDepositWithdrawFees': false,
+                'fetchFundingHistory': false,
+                'fetchFundingRate': false,
+                'fetchFundingRateHistory': false,
+                'fetchFundingRates': false,
+                'fetchIndexOHLCV': false,
+                'fetchL3OrderBook': false,
+                'fetchLedger': true,
+                'fetchLeverage': false,
+                'fetchLeverageTiers': false,
+                'fetchMarketLeverageTiers': false,
+                'fetchMarkets': true,
+                'fetchMarkOHLCV': false,
+                'fetchMyTrades': true,
+                'fetchOHLCV': true,
+                'fetchOpenInterestHistory': false,
+                'fetchOpenOrder': false,
+                'fetchOpenOrders': true,
+                'fetchOrder': true,
+                'fetchOrderBook': true,
+                'fetchOrderBooks': false,
+                'fetchOrders': true,
+                'fetchOrderTrades': true,
+                'fetchPosition': false,
+                'fetchPositions': false,
+                'fetchPositionsRisk': false,
+                'fetchPremiumIndexOHLCV': false,
+                'fetchStatus': false,
+                'fetchTicker': true,
+                'fetchTickers': true,
+                'fetchTime': true,
+                'fetchTrades': true,
+                'fetchTradingFee': false,
+                'fetchTradingFees': true,
+                'fetchTradingLimits': false,
+                'fetchTransactionFee': false,
+                'fetchTransactionFees': false,
+                'fetchTransactions': true,
+                'fetchTransfers': true,
+                'fetchWithdrawal': false,
+                'fetchWithdrawals': false,
+                'fetchWithdrawalWhitelist': false,
+                'reduceMargin': false,
+                'repayMargin': false,
+                'setLeverage': false,
+                'setMargin': false,
+                'setMarginMode': false,
+                'setPositionMode': false,
+                'signIn': false,
+                'transfer': true,
+                'withdraw': true,
+                'ws': false,
+            },
+            'timeframes': {
+                '1m': '1m',
+                '5m': '5m',
+                '30m': '30m',
+            },
+            'urls': {
+                'logo': 'https://github-production-user-asset-6210df.s3.amazonaws.com/1294454/281108917-eff2ae1d-ce8a-4b2a-950d-8678b12da965.jpg',
+                'api': {
+                    'public': 'https://trade-api.coinlist.co',
+                    'private': 'https://trade-api.coinlist.co',
+                },
+                'www': 'https://coinlist.co',
+                'doc': [
+                    'https://trade-docs.coinlist.co',
+                ],
+                'fees': 'https://coinlist.co/fees',
+            },
+            'api': {
+                'public': {
+                    'get': {
+                        'v1/symbols': 1,
+                        'v1/symbols/summary': 1,
+                        'v1/symbols/{symbol}': 1,
+                        'v1/symbols/{symbol}/summary': 1,
+                        'v1/symbols/{symbol}/book': 1,
+                        'v1/symbols/{symbol}/quote': 1,
+                        'v1/symbols/{symbol}/candles': 1,
+                        'v1/symbols/{symbol}/auctions': 1,
+                        'v1/symbols/{symbol}/auctions/{auction_code}': 1,
+                        'v1/time': 1,
+                        'v1/assets': 1,
+                    },
+                },
+                'private': {
+                    'get': {
+                        'v1/fees': 1,
+                        'v1/accounts': 1,
+                        'v1/accounts/{trader_id}': 1,
+                        'v1/accounts/{trader_id}/ledger': 1,
+                        'v1/accounts/{trader_id}/wallets': 1,
+                        'v1/accounts/{trader_id}/wallet-ledger': 1,
+                        'v1/accounts/{trader_id}/ledger-summary': 1,
+                        'v1/keys': 1,
+                        'v1/fills': 1,
+                        'v1/orders': 1,
+                        'v1/orders/{order_id}': 1,
+                        'v1/reports': 1,
+                        'v1/balances': 1,
+                        'v1/transfers': 1,
+                        'v1/user': 1,
+                        'v1/credits': 1, // not unified
+                    },
+                    'post': {
+                        'v1/keys': 1,
+                        'v1/orders': 1,
+                        'v1/orders/cancel-all-after': 1,
+                        'v1/reports': 1,
+                        'v1/transfers/to-wallet': 1,
+                        'v1/transfers/from-wallet': 1,
+                        'v1/transfers/internal-transfer': 1,
+                        'v1/transfers/withdrawal-request': 1,
+                        'v1/orders/bulk': 1, // not unified
+                    },
+                    'patch': {
+                        'v1/orders/{order_id}': 1,
+                        'v1/orders/bulk': 1, // not unified
+                    },
+                    'delete': {
+                        'v1/keys/{key}': 1,
+                        'v1/orders': 1,
+                        'v1/orders/{order_id}': 1,
+                        'v1/orders/bulk': 1,
+                    },
+                },
+            },
+            'fees': {
+                'trading': {
+                    'feeSide': 'get',
+                    'tierBased': true,
+                    'percentage': true,
+                    'taker': this.parseNumber('0.0045'),
+                    'maker': this.parseNumber('0.0025'),
+                    'tiers': {
+                        'taker': [
+                            [this.parseNumber('0'), this.parseNumber('0.0045')],
+                            [this.parseNumber('20000'), this.parseNumber('0.003')],
+                            [this.parseNumber('50000'), this.parseNumber('0.0025')],
+                            [this.parseNumber('100000'), this.parseNumber('0.002')],
+                            [this.parseNumber('500000'), this.parseNumber('0.0018')],
+                            [this.parseNumber('750000'), this.parseNumber('0.0018')],
+                            [this.parseNumber('1000000'), this.parseNumber('0.0016')],
+                            [this.parseNumber('2500000'), this.parseNumber('0.0013')],
+                            [this.parseNumber('5000000'), this.parseNumber('0.0012')],
+                            [this.parseNumber('10000000'), this.parseNumber('0.001')],
+                            [this.parseNumber('50000000'), this.parseNumber('0.0005')],
+                            [this.parseNumber('100000000'), this.parseNumber('0.0005')],
+                        ],
+                        'maker': [
+                            [this.parseNumber('0'), this.parseNumber('0.0025')],
+                            [this.parseNumber('20000'), this.parseNumber('0.0025')],
+                            [this.parseNumber('50000'), this.parseNumber('0.0025')],
+                            [this.parseNumber('100000'), this.parseNumber('0.002')],
+                            [this.parseNumber('500000'), this.parseNumber('0.0015')],
+                            [this.parseNumber('750000'), this.parseNumber('0.0012')],
+                            [this.parseNumber('1000000'), this.parseNumber('0.001')],
+                            [this.parseNumber('2500000'), this.parseNumber('0.0008')],
+                            [this.parseNumber('5000000'), this.parseNumber('0.0007')],
+                            [this.parseNumber('10000000'), this.parseNumber('0.0006')],
+                            [this.parseNumber('50000000'), this.parseNumber('0.0000')],
+                            [this.parseNumber('100000000'), this.parseNumber('0.00')],
+                        ],
+                    },
+                },
+            },
+            'precisionMode': _base_functions_number_js__WEBPACK_IMPORTED_MODULE_1__/* .TICK_SIZE */ .sh,
+            // exchange-specific options
+            'options': {
+                'accountsByType': {
+                    'CoinList Pro': 'trading',
+                    'CoinList Pro trading account': 'trading',
+                    'Pro': 'trading',
+                    'pro': 'trading',
+                    'trade': 'trading',
+                    'trading': 'trading',
+                    'CoinList': 'funding',
+                    'CoinList wallet': 'funding',
+                    'Wallet': 'funding',
+                    'wallet': 'funding',
+                    'fund': 'funding',
+                    'funding': 'funding',
+                },
+            },
+            'exceptions': {
+                // https://trade-docs.coinlist.co/?javascript--nodejs#message-codes
+                'exact': {
+                    'AUTH_SIG_INVALID': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.AuthenticationError,
+                    'DENIED_MAINTENANCE': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.OnMaintenance,
+                    'ORDER_REJECT_BAD_STATUS': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.InvalidOrder,
+                    'ORDER_REJECT_INVALID_POST_ONLY': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.InvalidOrder,
+                    'ORDER_REJECT_INVALID_CLOSE_ONLY': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.InvalidOrder,
+                    'ORDER_REJECT_POST_ONLY_REQUIRED': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.InvalidOrder,
+                    'ORDER_REJECT_FROZEN_ORDER': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.InvalidOrder,
+                    'ORDER_REJECT_LIMIT_PRICE_PROTECTION_VIOLATION': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.InvalidOrder,
+                    'ORDER_REJECT_CLOSED': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.NotSupported,
+                    'ORDER_REJECT_MAX_ORDERS': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.BadRequest,
+                    'ORDER_REJECT_NOT_FOUND': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.OrderNotFound,
+                    'ORDER_REJECT_PARSE_ERROR': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.BadRequest,
+                    'ORDER_REJECT_PRICE_INVALID': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.InvalidOrder,
+                    'ORDER_REJECT_QUANTITY_ZERO': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.InvalidOrder,
+                    'ORDER_REJECT_TOKEN_LIMIT': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.InsufficientFunds,
+                    'ORDER_REJECT_TOKEN_LIMIT_OTHER': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.InvalidOrder,
+                    'ORDER_REJECT_SELF_TRADE': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.InvalidOrder,
+                    'ORDER_VALIDATE_BAD_SIZE_ALIGNMENT': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.InvalidOrder,
+                    'ORDER_VALIDATE_BAD_TICK_ALIGNMENT': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.InvalidOrder,
+                    'ORDER_VALIDATE_SYMBOL_NOT_FOUND': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.BadSymbol,
+                    'TRANSFERS_WITHDRAWAL_REQUEST_TOO_LARGE': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.InsufficientFunds,
+                    'WITHDRAWAL_REQUEST_NOT_ALLOWED': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.PermissionDenied, // {"message":"Withdrawal from CoinList not allowed for trader.","message_code":"WITHDRAWAL_REQUEST_NOT_ALLOWED","message_details":{"asset":"USDT","amount":"5","trader_id":"9c6f737e-a829-4843-87b1-b1ce86f2853b","destination_address":"0x9050dfA063D1bE7cA711c750b18D51fDD13e90Ee"}}
+                },
+                'broad': {
+                    'A destinationAddress is required for non-USD withdrawals': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.InvalidAddress,
+                    'fails to match the JsonSchema date-time format pattern': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.BadRequest,
+                    'is required': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.ArgumentsRequired,
+                    'must be a string': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.BadRequest,
+                    'must be a valid GUID': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.BadRequest,
+                    'must be greater than or equal to': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.BadRequest,
+                    'must be less than or equal to': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.BadRequest,
+                    'must be one of': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.BadRequest,
+                    'Symbol not found': _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.BadSymbol, // {"message":"Symbol not found: {symbol}"}
+                },
+            },
+        });
+    }
+    calculateRateLimiterCost(api, method, path, params, config = {}) {
+        if (Array.isArray(params)) {
+            const length = params.length;
+            return Math.ceil(length / 2);
+        }
+        return 1;
+    }
+    async fetchTime(params = {}) {
+        /**
+         * @method
+         * @name coinlist#fetchTime
+         * @description fetches the current integer timestamp in milliseconds from the exchange server
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#get-system-time
+         * @param {object} [params] extra parameters specific to the coinlist api endpoint
+         * @returns {int} the current integer timestamp in milliseconds from the exchange server
+         */
+        const response = await this.publicGetV1Time(params);
+        //
+        //     {
+        //         "epoch": 1698087996.039,
+        //         "iso": "2023-10-23T19:06:36.039Z"
+        //     }
+        //
+        const string = this.safeString(response, 'iso');
+        return this.parse8601(string);
+    }
+    async fetchCurrencies(params = {}) {
+        /**
+         * @method
+         * @name coinlist#fetchCurrencies
+         * @description fetches all available currencies on an exchange
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#list-supported-assets
+         * @param {object} [params] extra parameters specific to the coinlist api endpoint
+         * @returns {object} an associative dictionary of currencies
+         */
+        const response = await this.publicGetV1Assets(params);
+        //
+        //     {
+        //         "assets": [
+        //             {
+        //                 "asset": "AAVE",
+        //                 "index_code": ".AAVEUSD",
+        //                 "decimal_places": 18,
+        //                 "min_withdrawal": "1.0000",
+        //                 "is_transferable": true,
+        //                 "is_visible": true
+        //             },
+        //             {
+        //                 "asset": "ALGO",
+        //                 "index_code": ".ALGOUSD",
+        //                 "decimal_places": 6,
+        //                 "min_withdrawal": "1.0000",
+        //                 "is_transferable": true,
+        //                 "is_visible": true
+        //             }
+        //         ]
+        //     }
+        //
+        const currencies = this.safeValue(response, 'assets', []);
+        const result = {};
+        for (let i = 0; i < currencies.length; i++) {
+            const currency = currencies[i];
+            const id = this.safeString(currency, 'asset');
+            const code = this.safeCurrencyCode(id);
+            const isTransferable = this.safeValue(currency, 'is_transferable', false);
+            const withdrawEnabled = isTransferable;
+            const depositEnabled = isTransferable;
+            const active = isTransferable;
+            const decimalPlaces = this.safeString(currency, 'decimal_places');
+            const precision = this.parseNumber(this.parsePrecision(decimalPlaces));
+            const minWithdrawal = this.safeString(currency, 'min_withdrawal');
+            result[code] = {
+                'id': id,
+                'code': code,
+                'name': code,
+                'info': currency,
+                'active': active,
+                'deposit': depositEnabled,
+                'withdraw': withdrawEnabled,
+                'fee': undefined,
+                'precision': precision,
+                'limits': {
+                    'amount': { 'min': undefined, 'max': undefined },
+                    'withdraw': { 'min': minWithdrawal, 'max': undefined },
+                },
+                'networks': {},
+            };
+        }
+        return result;
+    }
+    async fetchMarkets(params = {}) {
+        /**
+         * @method
+         * @name coinlist#fetchMarkets
+         * @description retrieves data on all markets for coinlist
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#list-symbols
+         * @param {object} [params] extra parameters specific to the exchange api endpoint
+         * @returns {object[]} an array of objects representing market data
+         */
+        const response = await this.publicGetV1Symbols(params);
+        //
+        //     {
+        //         symbols: [
+        //             {
+        //                 symbol: 'CQT-USDT',
+        //                 base_currency: 'CQT',
+        //                 is_trader_geofenced: false,
+        //                 list_time: '2021-06-15T00:00:00.000Z',
+        //                 type: 'spot',
+        //                 series_code: 'CQT-USDT-SPOT',
+        //                 long_name: 'Covalent',
+        //                 asset_class: 'CRYPTO',
+        //                 minimum_price_increment: '0.0001',
+        //                 minimum_size_increment: '0.0001',
+        //                 quote_currency: 'USDT',
+        //                 index_code: null,
+        //                 price_band_threshold_market: '0.05',
+        //                 price_band_threshold_limit: '0.25',
+        //                 last_price: '0.12160000',
+        //                 fair_price: '0.12300000',
+        //                 index_price: null
+        //             },
+        //         ]
+        //     }
+        //
+        const markets = this.safeValue(response, 'symbols', []);
+        const result = [];
+        for (let i = 0; i < markets.length; i++) {
+            const market = markets[i];
+            const id = this.safeString(market, 'symbol');
+            const baseId = this.safeString(market, 'base_currency');
+            const quoteId = this.safeString(market, 'quote_currency');
+            const base = this.safeCurrencyCode(baseId);
+            const quote = this.safeCurrencyCode(quoteId);
+            const amountPrecision = this.safeString(market, 'minimum_size_increment');
+            const pricePrecision = this.safeString(market, 'minimum_price_increment');
+            const created = this.safeString(market, 'list_time');
+            result.push({
+                'id': id,
+                'symbol': base + '/' + quote,
+                'base': base,
+                'quote': quote,
+                'settle': undefined,
+                'baseId': baseId,
+                'quoteId': quoteId,
+                'settleId': undefined,
+                'type': 'spot',
+                'spot': true,
+                'margin': false,
+                'swap': false,
+                'future': false,
+                'option': false,
+                'active': true,
+                'contract': false,
+                'linear': undefined,
+                'inverse': undefined,
+                'contractSize': undefined,
+                'expiry': undefined,
+                'expiryDatetime': undefined,
+                'strike': undefined,
+                'optionType': undefined,
+                'precision': {
+                    'amount': this.parseNumber(amountPrecision),
+                    'price': this.parseNumber(pricePrecision),
+                },
+                'limits': {
+                    'leverage': {
+                        'min': undefined,
+                        'max': undefined,
+                    },
+                    'amount': {
+                        'min': undefined,
+                        'max': undefined,
+                    },
+                    'price': {
+                        'min': undefined,
+                        'max': undefined,
+                    },
+                    'cost': {
+                        'min': undefined,
+                        'max': undefined,
+                    },
+                },
+                'created': this.parse8601(created),
+                'info': market,
+            });
+        }
+        return result;
+    }
+    async fetchTickers(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name coinlist#fetchTickers
+         * @description fetches price tickers for multiple markets, statistical calculations with the information calculated over the past 24 hours each market
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#get-symbol-summaries
+         * @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 coinlist api endpoint
+         * @returns {object} a dictionary of [ticker structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#ticker-structure}
+         */
+        await this.loadMarkets();
+        const request = {};
+        const tickers = await this.publicGetV1SymbolsSummary(this.extend(request, params));
+        //
+        //     {
+        //         "MATIC-USD": {
+        //             "type":"spot",
+        //             "last_price":"0.60990000",
+        //             "lowest_ask":"0.61190000",
+        //             "highest_bid":"0.60790000",
+        //             "last_trade": {
+        //                 "price":"0.60000000",
+        //                 "volume":"2.0000",
+        //                 "imbalance":"198.0000",
+        //                 "logicalTime":"2023-10-22T23:02:25.000Z",
+        //                 "auctionCode":"MATIC-USD-2023-10-22T23:02:25.000Z"
+        //         },
+        //             "volume_base_24h":"34.0555",
+        //             "volume_quote_24h":"19.9282",
+        //             "price_change_percent_24h":"7.50925436",
+        //             "highest_price_24h":"0.68560000",
+        //             "lowest_price_24h":"0.55500000"
+        //         },
+        //     }
+        //
+        return this.parseTickers(tickers, symbols, params);
+    }
+    async fetchTicker(symbol, params = {}) {
+        /**
+         * @method
+         * @name coinlist#fetchTicker
+         * @description fetches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#get-market-summary
+         * @param {string} symbol unified symbol of the market to fetch the ticker for
+         * @param {object} [params] extra parameters specific to the coinlist api endpoint
+         * @returns {object} a [ticker structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#ticker-structure}
+         */
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const request = {
+            'symbol': market['id'],
+        };
+        const ticker = await this.publicGetV1SymbolsSymbolSummary(this.extend(request, params));
+        //
+        //     {
+        //         "type":"spot",
+        //         "last_price":"31125.00000000",
+        //         "lowest_ask":"31349.99000000",
+        //         "highest_bid":"30900.00000000",
+        //         "last_trade": {
+        //             "price":"31000.00000000",
+        //             "volume":"0.0003",
+        //             "imbalance":"0.0000",
+        //             "logicalTime":"2023-10-23T16:57:15.000Z",
+        //             "auctionCode":"BTC-USDT-2023-10-23T16:57:15.000Z"
+        //         },
+        //         "volume_base_24h":"0.3752",
+        //         "volume_quote_24h":"11382.7181",
+        //         "price_change_percent_24h":"3.66264694",
+        //         "highest_price_24h":"31225.12000000",
+        //         "lowest_price_24h":"29792.81000000"
+        //     }
+        //
+        return this.parseTicker(ticker, market);
+    }
+    parseTicker(ticker, market = undefined) {
+        //
+        //     {
+        //         "type":"spot",
+        //         "last_price":"0.60990000",
+        //         "lowest_ask":"0.61190000",
+        //         "highest_bid":"0.60790000",
+        //         "last_trade": {
+        //             "price":"0.60000000",
+        //             "volume":"2.0000",
+        //             "imbalance":"198.0000",
+        //             "logicalTime":"2023-10-22T23:02:25.000Z",
+        //             "auctionCode":"MATIC-USD-2023-10-22T23:02:25.000Z"
+        //          },
+        //         "volume_base_24h":"34.0555",
+        //         "volume_quote_24h":"19.9282",
+        //         "price_change_percent_24h":"7.50925436",
+        //         "highest_price_24h":"0.68560000",
+        //         "lowest_price_24h":"0.55500000"
+        //     }
+        //
+        const lastTrade = this.safeValue(ticker, 'last_trade', {});
+        const timestamp = this.parse8601(this.safeString(lastTrade, 'logicalTime'));
+        const bid = this.safeString(ticker, 'highest_bid');
+        const ask = this.safeString(ticker, 'lowest_ask');
+        const baseVolume = this.safeString(ticker, 'volume_base_24h');
+        const quoteVolume = this.safeString(ticker, 'volume_quote_24h');
+        const high = this.safeString(ticker, 'highest_price_24h');
+        const low = this.safeString(ticker, 'lowest_price_24h');
+        const close = this.safeString(ticker, 'last_price');
+        const changePcnt = this.safeString(ticker, 'price_change_percent_24h');
+        return this.safeTicker({
+            'symbol': market['symbol'],
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'open': undefined,
+            'high': high,
+            'low': low,
+            'close': close,
+            'bid': bid,
+            'bidVolume': undefined,
+            'ask': ask,
+            'askVolume': undefined,
+            'vwap': undefined,
+            'previousClose': undefined,
+            'change': undefined,
+            'percentage': changePcnt,
+            'average': undefined,
+            'baseVolume': baseVolume,
+            'quoteVolume': quoteVolume,
+            'info': ticker,
+        }, market);
+    }
+    async fetchOrderBook(symbol, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name coinlist#fetchOrderBook
+         * @description fetches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#get-order-book-level-2
+         * @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 (default 100, max 200)
+         * @param {object} [params] extra parameters specific to the coinlist api endpoint
+         * @returns {object} A dictionary of [order book structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-book-structure} indexed by market symbols
+         */
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const request = {
+            'symbol': market['id'],
+        };
+        const response = await this.publicGetV1SymbolsSymbolBook(this.extend(request, params));
+        //
+        //     {
+        //         "bids": [
+        //             [ "30900.00000000", "0.0001" ],
+        //             [ "30664.21000000", "0.0172" ],
+        //             [ "30664.20000000", "0.0906" ],
+        //         ],
+        //         "asks": [
+        //             [ "31349.99000000", "0.0003" ],
+        //             [ "31350.00000000", "0.0023" ],
+        //             [ "31359.33000000", "0.0583" ],
+        //         ],
+        //         "after_auction_code": "BTC-USDT-2023-10-23T18:40:51.000Z",
+        //         "call_time": "2023-10-23T18:40:51.068Z",
+        //         "logical_time": "2023-10-23T18:40:51.000Z"
+        //     }
+        //
+        const logical_time = this.parse8601(this.safeString(response, 'logical_time'));
+        const orderbook = this.parseOrderBook(response, symbol, logical_time);
+        orderbook['nonce'] = undefined;
+        return orderbook;
+    }
+    async fetchOHLCV(symbol, timeframe = '1m', since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name coinlist#fetchOHLCV
+         * @description fetches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#get-candles
+         * @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 coinlist api endpoint
+         * @param {int} [params.until] the latest time in ms to fetch entries for
+         * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
+         */
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const granularity = this.safeString(this.timeframes, timeframe);
+        const request = {
+            'symbol': market['id'],
+            'granularity': granularity,
+        };
+        if (since !== undefined) {
+            request['start_time'] = this.iso8601(since);
+            if (limit !== undefined) {
+                const duration = this.parseTimeframe(timeframe) * 1000;
+                request['end_time'] = this.iso8601(this.sum(since, duration * (limit)));
+            }
+            else {
+                request['end_time'] = this.iso8601(this.milliseconds());
+            }
+        }
+        const until = this.safeInteger2(params, 'till', 'until');
+        if (until !== undefined) {
+            params = this.omit(params, ['till', 'until']);
+            request['end_time'] = this.iso8601(until);
+        }
+        const response = await this.publicGetV1SymbolsSymbolCandles(this.extend(request, params));
+        //
+        //     {
+        //         "candles": [
+        //             [
+        //                 "2023-10-17T15:00:00.000Z",
+        //                 "28522.96000000",
+        //                 "28522.96000000",
+        //                 "28522.96000000",
+        //                 "28522.96000000",
+        //                 "0.1881",
+        //                 null
+        //             ],
+        //             [
+        //                 "2023-10-17T15:30:00.000Z",
+        //                 "28582.64000000",
+        //                 "28582.64000000",
+        //                 "28582.64000000",
+        //                 "28582.64000000",
+        //                 "0.0050",
+        //                 null
+        //             ]
+        //         ]
+        //     }
+        //
+        const candles = this.safeValue(response, 'candles', []);
+        return this.parseOHLCVs(candles, market, timeframe, since, limit);
+    }
+    parseOHLCV(ohlcv, market = undefined) {
+        //
+        //     [
+        //         "2023-10-17T15:30:00.000Z",
+        //         "28582.64000000",
+        //         "28582.64000000",
+        //         "28582.64000000",
+        //         "28582.64000000",
+        //         "0.0050",
+        //         null
+        //     ]
+        //
+        return [
+            this.parse8601(this.safeString(ohlcv, 0)),
+            this.safeNumber(ohlcv, 1),
+            this.safeNumber(ohlcv, 2),
+            this.safeNumber(ohlcv, 3),
+            this.safeNumber(ohlcv, 4),
+            this.safeNumber(ohlcv, 5),
+        ];
+    }
+    async fetchTrades(symbol, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name coinlist#fetchTrades
+         * @description get the list of most recent trades for a particular symbol
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#list-auctions
+         * @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 (default 200, max 500)
+         * @param {object} [params] extra parameters specific to the coinlist api endpoint
+         * @param {int} [params.until] the latest time in ms to fetch entries for
+         * @returns {Trade[]} a list of [trade structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#public-trades}
+         */
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const request = {
+            'symbol': market['id'],
+        };
+        if (since !== undefined) {
+            request['start_time'] = this.iso8601(since);
+        }
+        if (limit !== undefined) {
+            request['count'] = limit;
+        }
+        const until = this.safeInteger2(params, 'till', 'until');
+        if (until !== undefined) {
+            params = this.omit(params, ['till', 'until']);
+            request['end_time'] = this.iso8601(until);
+        }
+        const response = await this.publicGetV1SymbolsSymbolAuctions(this.extend(request, params));
+        //
+        //     {
+        //         "auctions": [
+        //             {
+        //                 "symbol":"BTC-USDT",
+        //                 "auction_code":"BTC-USDT-2023-10-01T08:05:56.000Z",
+        //                 "price":"27241.53000000",
+        //                 "volume":"0.0052",
+        //                 "imbalance":"-1.0983",
+        //                 "logical_time":"2023-10-01T08:05:56.000Z",
+        //                 "call_time":"2023-10-01T08:05:56.068Z"
+        //             },
+        //             {
+        //                 "symbol":"BTC-USDT",
+        //                 "auction_code":"BTC-USDT-2023-10-01T08:09:09.000Z",
+        //                 "price":"27236.83000000",
+        //                 "volume":"0.0283",
+        //                 "imbalance":"-1.0754",
+        //                 "logical_time":"2023-10-01T08:09:09.000Z",
+        //                 "call_time":"2023-10-01T08:09:09.078Z"
+        //             }
+        //         ]
+        //     }
+        //
+        const auctions = this.safeValue(response, 'auctions', []);
+        return this.parseTrades(auctions, market, since, limit);
+    }
+    parseTrade(trade, market = undefined) {
+        //
+        // fetchTrades
+        //     {
+        //         "symbol": "BTC-USDT",
+        //         "auction_code": "BTC-USDT-2023-10-01T08:05:56.000Z",
+        //         "price": "27241.53000000",
+        //         "volume": "0.0052",
+        //         "imbalance": "-1.0983",
+        //         "logical_time": "2023-10-01T08:05:56.000Z",
+        //         "call_time": "2023-10-01T08:05:56.068Z"
+        //     }
+        //
+        // fetchMyTrades
+        //     {
+        //         symbol: 'ETH-USDT',
+        //         auction_code: 'ETH-USDT-2023-10-20T13:22:14.000Z',
+        //         order_id: '83ed365f-497d-433b-96c1-9d08c1a12842',
+        //         quantity: '0.0008',
+        //         price: '1615.24000000',
+        //         fee: '0.005815',
+        //         fee_type: 'taker',
+        //         fee_currency: 'USDT',
+        //         logical_time: '2023-10-20T13:22:14.000Z'
+        //     }
+        //
+        const marketId = this.safeString(trade, 'symbol');
+        market = this.safeMarket(marketId, market);
+        const symbol = market['symbol'];
+        const id = this.safeString(trade, 'auction_code');
+        const timestamp = this.parse8601(this.safeString(trade, 'logical_time'));
+        const priceString = this.safeString(trade, 'price');
+        let amountString = this.safeString2(trade, 'volume', 'quantity');
+        const order = this.safeString(trade, 'order_id');
+        let fee = undefined;
+        let side = undefined;
+        const feeCost = this.safeString(trade, 'fee');
+        if (feeCost !== undefined) {
+            // only in fetchMyTrades
+            const amountIsNegative = _base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise.stringLt */ .O.stringLt(amountString, '0');
+            if (amountIsNegative) {
+                side = 'sell';
+                amountString = _base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise.stringNeg */ .O.stringNeg(amountString);
+            }
+            else {
+                side = 'buy';
+            }
+            fee = {
+                'cost': feeCost,
+                'currency': this.safeString(trade, 'fee_currency'),
+            };
+        }
+        else {
+            const imbalance = this.safeString(trade, 'imbalance');
+            if (_base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise.stringLt */ .O.stringLt(imbalance, '0')) {
+                side = 'buy';
+            }
+            else {
+                side = 'sell';
+            }
+        }
+        const takerOrMaker = this.safeString(trade, 'fee_type');
+        return this.safeTrade({
+            'id': id,
+            'order': order,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'symbol': symbol,
+            'type': undefined,
+            'side': side,
+            'takerOrMaker': takerOrMaker,
+            'price': priceString,
+            'amount': amountString,
+            'cost': undefined,
+            'fee': fee,
+            'info': trade,
+        }, market);
+    }
+    async fetchTradingFees(params = {}) {
+        /**
+         * @method
+         * @name coinlist#fetchTradingFees
+         * @description fetch the trading fees for multiple markets
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#list-fees
+         * @param {object} [params] extra parameters specific to the coinlist api endpoint
+         * @returns {object} a dictionary of [fee structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#fee-structure} indexed by market symbols
+         */
+        await this.loadMarkets();
+        const response = await this.privateGetV1Fees(params);
+        //
+        //     {
+        //         fees_by_symbols: {
+        //             'BTC-USD,BTC-USDT,ETH-USD,ETH-USDT,ETH-BTC,AAVE-USD,AAVE-USDT,ALGO-USD,ALGO-USDT,AVAX-USD,AVAX-USDT,BICO-USD,BICO-USDT,BLD-USD,BLD-USDT,BTRST-USDT,BZZ-USDT,CELO-USD,CELO-BTC,CFG-USD,CFG-USDT,CLV-USDT,COMP-USD,COMP-USDT,CYBER-USDT,CQT-USDT,CSPR-USD,CSPR-USDT,CUSD-USD,CUSD-USDC,DOGE-USD,DOGE-USDT,DOT-USD,DOT-USDT,EFI-USDT,FIL-USD,FIL-USDT,FLOW-USD,FLOW-USDT,GAL-USD,GAL-USDT,GODS-USDT,GOG-USDT,HMT-USD,HMT-USDT,ICP-USD,ICP-USDT,IMX-USD,IMX-USDT,LINK-USD,LINK-USDT,MATIC-USD,MATIC-USDT,MINA-USD,MINA-USDT,MKR-USD,MKR-USDT,NEON-USDT,NYM-USD,NYM-USDT,OCEAN-USD,OXT-USD,ROSE-USD,ROSE-USDT,SKL-USD,SKL-USDT,SOL-USD,SOL-USDT,STX-USDT,SUI-USDT,T-USDT,UNI-USD,UNI-USDT,USDT-USD,VEGA-USDT,WAXL-USD,WAXL-USDT,WBTC-BTC,WCFG-USD,WCFG-USDT,XTZ-USD': {
+        //                 base: {
+        //                     fees: { maker: '0', taker: '0.0045', liquidation: '0' },
+        //                     floors: { maker: null, taker: null }
+        //                 },
+        //                 volume_tier_1: {
+        //                     fees: { maker: '0', taker: '0.003', liquidation: '0' },
+        //                     floors: { maker: null, taker: null }
+        //                 },
+        //                 volume_tier_2: {
+        //                     fees: { maker: '0', taker: '0.0025', liquidation: '0' },
+        //                     floors: { maker: null, taker: null }
+        //                 },
+        //                 volume_tier_3: {
+        //                     fees: { maker: '0', taker: '0.002', liquidation: '0' },
+        //                     floors: { maker: null, taker: null }
+        //                 },
+        //                 volume_tier_4: {
+        //                     fees: { maker: '0', taker: '0.0018', liquidation: '0' },
+        //                     floors: { maker: null, taker: null }
+        //                 },
+        //                 volume_tier_5: {
+        //                     fees: { maker: '0', taker: '0.0018', liquidation: '0' },
+        //                     floors: { maker: null, taker: null }
+        //                 },
+        //                 volume_tier_6: {
+        //                     fees: { maker: '0', taker: '0.0016', liquidation: '0' },
+        //                     floors: { maker: null, taker: null }
+        //                 },
+        //                 volume_tier_7: {
+        //                     fees: { maker: '0', taker: '0.0013', liquidation: '0' },
+        //                     floors: { maker: null, taker: null }
+        //                 },
+        //                 volume_tier_8: {
+        //                     fees: { maker: '0', taker: '0.0012', liquidation: '0' },
+        //                     floors: { maker: null, taker: null }
+        //                 },
+        //                 volume_tier_9: {
+        //                     fees: { maker: '0', taker: '0.001', liquidation: '0' },
+        //                     floors: { maker: null, taker: null }
+        //                 }
+        //                 volume_tier_10: {
+        //                     fees: { maker: '0', taker: '0.0005', liquidation: '0' },
+        //                     floors: { maker: null, taker: null }
+        //                 },
+        //                 volume_tier_11: {
+        //                     fees: { maker: '0', taker: '0.0005', liquidation: '0' },
+        //                     floors: { maker: null, taker: null }
+        //                 },
+        //             }
+        //         }
+        //     }
+        //
+        const fees = this.safeValue(response, 'fees_by_symbols', {});
+        const result = {};
+        const groupsOfSymbols = Object.keys(fees);
+        for (let i = 0; i < groupsOfSymbols.length; i++) {
+            const group = groupsOfSymbols[i];
+            const feeTiers = this.safeValue(fees, group, {});
+            const tiers = this.parseFeeTiers(feeTiers);
+            const firstTier = this.safeValue(feeTiers, 'base', {});
+            const firstTierFees = this.safeValue(firstTier, 'fees', {});
+            const ids = group.split(',');
+            for (let j = 0; j < ids.length; j++) {
+                const id = ids[j];
+                const market = this.safeMarket(id);
+                const symbol = market['symbol'];
+                const info = {};
+                info[group] = feeTiers;
+                result[symbol] = {
+                    'info': info,
+                    'symbol': symbol,
+                    'maker': this.safeNumber(firstTierFees, 'maker'),
+                    'taker': this.safeNumber(firstTierFees, 'taker'),
+                    'percentage': true,
+                    'tierBased': true,
+                    'tiers': tiers,
+                };
+            }
+        }
+        return result;
+    }
+    parseFeeTiers(feeTiers, market = undefined) {
+        //
+        //     base: {
+        //         fees: { maker: '0', taker: '0.0045', liquidation: '0' },
+        //         floors: { maker: null, taker: null }
+        //     },
+        //     volume_tier_1: {
+        //         fees: { maker: '0', taker: '0.003', liquidation: '0' },
+        //         floors: { maker: null, taker: null }
+        //     },
+        //     volume_tier_2: {
+        //         fees: { maker: '0', taker: '0.0025', liquidation: '0' },
+        //         floors: { maker: null, taker: null }
+        //     },
+        //     volume_tier_3: {
+        //         fees: { maker: '0', taker: '0.002', liquidation: '0' },
+        //         floors: { maker: null, taker: null }
+        //     },
+        //     volume_tier_4: {
+        //         fees: { maker: '0', taker: '0.0018', liquidation: '0' },
+        //         floors: { maker: null, taker: null }
+        //     },
+        //     volume_tier_5: {
+        //         fees: { maker: '0', taker: '0.0018', liquidation: '0' },
+        //         floors: { maker: null, taker: null }
+        //     },
+        //     volume_tier_6: {
+        //         fees: { maker: '0', taker: '0.0016', liquidation: '0' },
+        //         floors: { maker: null, taker: null }
+        //     },
+        //     volume_tier_7: {
+        //         fees: { maker: '0', taker: '0.0013', liquidation: '0' },
+        //         floors: { maker: null, taker: null }
+        //     },
+        //     volume_tier_8: {
+        //         fees: { maker: '0', taker: '0.0012', liquidation: '0' },
+        //         floors: { maker: null, taker: null }
+        //     },
+        //     volume_tier_9: {
+        //         fees: { maker: '0', taker: '0.001', liquidation: '0' },
+        //         floors: { maker: null, taker: null }
+        //     }
+        //     volume_tier_10: {
+        //         fees: { maker: '0', taker: '0.0005', liquidation: '0' },
+        //         floors: { maker: null, taker: null }
+        //     },
+        //     volume_tier_11: {
+        //         fees: { maker: '0', taker: '0.0005', liquidation: '0' },
+        //         floors: { maker: null, taker: null }
+        //     },
+        //
+        let takerFees = [];
+        let makerFees = [];
+        const keys = Object.keys(feeTiers);
+        const keysLength = keys.length;
+        if (keysLength > 0) {
+            for (let i = 0; i < keysLength; i++) {
+                const key = keys[i];
+                const tier = this.safeValue(feeTiers, key, {});
+                const tierFees = this.safeValue(tier, 'fees', {});
+                const taker = this.safeString(tierFees, 'taker');
+                const maker = this.safeString(tierFees, 'maker');
+                makerFees.push([undefined, this.parseNumber(maker)]);
+                takerFees.push([undefined, this.parseNumber(taker)]);
+            }
+            takerFees = this.sortBy(takerFees, 1, true);
+            makerFees = this.sortBy(makerFees, 1, true);
+            const firstTier = this.safeValue(takerFees, 0, []);
+            const exchangeFees = this.safeValue(this, 'fees', {});
+            const exchangeFeesTrading = this.safeValue(exchangeFees, 'trading', {});
+            const exchangeFeesTradingTiers = this.safeValue(exchangeFeesTrading, 'tiers', {});
+            const exchangeFeesTradingTiersTaker = this.safeValue(exchangeFeesTradingTiers, 'taker', []);
+            const exchangeFeesTradingTiersMaker = this.safeValue(exchangeFeesTradingTiers, 'maker', []);
+            if ((keysLength === exchangeFeesTradingTiersTaker.length) && (firstTier.length > 0)) {
+                for (let i = 0; i < keysLength; i++) {
+                    takerFees[i][0] = exchangeFeesTradingTiersTaker[i][0];
+                    makerFees[i][0] = exchangeFeesTradingTiersMaker[i][0];
+                }
+            }
+        }
+        return {
+            'maker': makerFees,
+            'taker': takerFees,
+        };
+    }
+    async fetchAccounts(params = {}) {
+        /**
+         * @method
+         * @name coinlist#fetchAccounts
+         * @description fetch all the accounts associated with a profile
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#list-accounts
+         * @param {object} [params] extra parameters specific to the coinlist api endpoint
+         * @returns {object} a dictionary of [account structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#account-structure} indexed by the account type
+         */
+        await this.loadMarkets();
+        const response = await this.privateGetV1Accounts(params);
+        //
+        //     {
+        //         "accounts": [
+        //             {
+        //                 "trader_id": "b18507ce-7d55-4bf1-b12a-0ccca5b90936",
+        //                 "name": "string"
+        //             }
+        //         ]
+        //     }
+        //
+        const accounts = this.safeValue(response, 'accounts', []);
+        return this.parseAccounts(accounts, params);
+    }
+    parseAccount(account) {
+        //
+        //     {
+        //         "trader_id": "b18507ce-7d55-4bf1-b12a-0ccca5b90936",
+        //         "name": "string"
+        //     }
+        //
+        return {
+            'id': this.safeString(account, 'trader_id'),
+            'type': 'trading',
+            'code': undefined,
+            'info': account,
+        };
+    }
+    async fetchBalance(params = {}) {
+        /**
+         * @method
+         * @name coinlist#fetchBalance
+         * @description query for balance and get the amount of funds available for trading or funds locked in orders
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#list-balances
+         * @param {object} [params] extra parameters specific to the coinlist api endpoint
+         * @returns {object} a [balance structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#balance-structure}
+         */
+        await this.loadMarkets();
+        const response = await this.privateGetV1Balances(params);
+        return this.parseBalance(response);
+    }
+    parseBalance(response) {
+        //
+        //     {
+        //         "asset_balances": {
+        //             "BTC": "0.00308696",
+        //             "ETH": "20.000000000000000000"
+        //         },
+        //         "asset_holds": {
+        //             "BTC": "0.00000000",
+        //             "ETH": "1.000000000000000000"
+        //         },
+        //         "net_liquidation_value_usd": "string"
+        //     }
+        //
+        const timestamp = this.milliseconds();
+        const result = {
+            'info': response,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+        };
+        const totalBalances = this.safeValue(response, 'asset_balances', {});
+        const usedBalances = this.safeValue(response, 'asset_holds', {});
+        const currencyIds = Object.keys(totalBalances);
+        for (let i = 0; i < currencyIds.length; i++) {
+            const currencyId = currencyIds[i];
+            const code = this.safeCurrencyCode(currencyId);
+            const account = this.account();
+            account['total'] = this.safeString(totalBalances, currencyId);
+            account['used'] = this.safeString(usedBalances, currencyId, '0');
+            result[code] = account;
+        }
+        return this.safeBalance(result);
+    }
+    async fetchMyTrades(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name coinlist#fetchMyTrades
+         * @description fetch all trades made by the user
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#list-fills
+         * @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 (default 200, max 500)
+         * @param {object} [params] extra parameters specific to the coinlist api endpoint
+         * @param {int} [params.until] the latest time in ms to fetch entries for
+         * @returns {Trade[]} a list of [trade structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#trade-structure}
+         */
+        await this.loadMarkets();
+        const request = {};
+        let market = undefined;
+        if (symbol !== undefined) {
+            market = this.market(symbol);
+            request['symbol'] = market['id'];
+        }
+        if (since !== undefined) {
+            request['start_time'] = this.iso8601(since);
+        }
+        if (limit !== undefined) {
+            request['count'] = limit;
+        }
+        const until = this.safeInteger2(params, 'till', 'until');
+        if (until !== undefined) {
+            params = this.omit(params, ['till', 'until']);
+            request['end_time'] = this.iso8601(until);
+        }
+        const response = await this.privateGetV1Fills(this.extend(request, params));
+        //
+        //     {
+        //         fills: [
+        //             {
+        //                 symbol: 'ETH-USDT',
+        //                 auction_code: 'ETH-USDT-2023-10-20T13:16:30.000Z',
+        //                 order_id: '39911d5f-c789-4a7d-ad34-820a804d1da6',
+        //                 quantity: '-0.0009',
+        //                 price: '1608.83000000',
+        //                 fee: '0.006516',
+        //                 fee_type: 'taker',
+        //                 fee_currency: 'USDT',
+        //                 logical_time: '2023-10-20T13:16:30.000Z'
+        //             },
+        //             {
+        //                 symbol: 'ETH-USDT',
+        //                 auction_code: 'ETH-USDT-2023-10-20T13:22:14.000Z',
+        //                 order_id: '83ed365f-497d-433b-96c1-9d08c1a12842',
+        //                 quantity: '0.0008',
+        //                 price: '1615.24000000',
+        //                 fee: '0.005815',
+        //                 fee_type: 'taker',
+        //                 fee_currency: 'USDT',
+        //                 logical_time: '2023-10-20T13:22:14.000Z'
+        //             },
+        //         ]
+        //     }
+        //
+        const fills = this.safeValue(response, 'fills', []);
+        return this.parseTrades(fills, market, since, limit);
+    }
+    async fetchOrderTrades(id, symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name coinlist#fetchOrderTrades
+         * @description fetch all the trades made from a single order
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#list-fills
+         * @param {string} id order id
+         * @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 to retrieve
+         * @param {object} [params] extra parameters specific to the coinlist api endpoint
+         * @returns {object[]} a list of [trade structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#trade-structure}
+         */
+        const request = {
+            'order_id': id,
+        };
+        return await this.fetchMyTrades(symbol, since, limit, this.extend(request, params));
+    }
+    async fetchOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name coinlist#fetchOrders
+         * @description fetches information on multiple orders made by the user
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#list-orders
+         * @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 (default 200, max 500)
+         * @param {object} [params] extra parameters specific to the coinlist api endpoint
+         * @param {int} [params.until] the latest time in ms to fetch entries for
+         * @param {string|string[]} [params.status] the status of the order - 'accepted', 'done', 'canceled', 'rejected', 'pending' (default [ 'accepted', 'done', 'canceled', 'rejected', 'pending' ])
+         * @returns {Order[]} a list of [order structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
+         */
+        await this.loadMarkets();
+        let status = this.safeString(params, 'status');
+        if (status === undefined) {
+            status = ['accepted', 'done', 'canceled', 'rejected', 'pending'];
+        }
+        const request = {
+            'status': status,
+        };
+        let market = undefined;
+        if (symbol !== undefined) {
+            market = this.market(symbol);
+            request['symbol'] = market['id'];
+        }
+        if (since !== undefined) {
+            request['start_time'] = this.iso8601(since);
+        }
+        if (limit !== undefined) {
+            request['count'] = limit;
+        }
+        const until = this.safeInteger2(params, 'till', 'until');
+        if (until !== undefined) {
+            params = this.omit(params, ['till', 'until']);
+            request['end_time'] = this.iso8601(until);
+        }
+        const response = await this.privateGetV1Orders(this.extend(request, params));
+        //
+        //     {
+        //         "orders":[
+        //             {
+        //                 "order_id":"913ea6e7-9fc9-43fb-9db1-f195d3baa93f",
+        //                 "price":"35800.00000000",
+        //                 "stop_price":null,
+        //                 "cost":"0.00000000",
+        //                 "fill_fees":"0.00000000",
+        //                 "trader_id":"9c6f737e-a829-4843-87b1-b1ce86f2853b",
+        //                 "status":"accepted",
+        //                 "epoch_timestamp":"2023-10-26T08:20:56.307Z",
+        //                 "origin":"web",
+        //                 "self_trade_prevention":null,
+        //                 "client_id":null,
+        //                 "created_at":"2023-10-26T08:20:56.307Z",
+        //                 "symbol":"BTC-USDT",
+        //                 "size":"0.0003",
+        //                 "side":"sell",
+        //                 "type":"limit",
+        //                 "post_only":false,
+        //                 "size_filled":"0.0000"
+        //             }
+        //         ]
+        //     }
+        //
+        const orders = this.safeValue(response, 'orders', []);
+        return this.parseOrders(orders, market, since, limit);
+    }
+    async fetchOrder(id, symbol = undefined, params = {}) {
+        /**
+         * @method
+         * @name coinlist#fetchOrder
+         * @description fetches information on an order made by the user
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#get-specific-order-by-id
+         * @param {int|string} id order id
+         * @param {string} symbol not used by coinlist fetchOrder ()
+         * @param {object} [params] extra parameters specific to the coinlist api endpoint
+         * @returns {object} An [order structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
+         */
+        await this.loadMarkets();
+        const request = {
+            'order_id': id,
+        };
+        const response = await this.privateGetV1OrdersOrderId(this.extend(request, params));
+        //
+        //     {
+        //         "order_id": "93101167-9065-4b9c-b98b-5d789a3ed9fe",
+        //         "client_id": "string",
+        //         "symbol": "string",
+        //         "type": "market",
+        //         "side": "buy",
+        //         "size": "string",
+        //         "price": "string",
+        //         "stop_price": "string",
+        //         "stop_trigger": "last",
+        //         "self_trade_prevention": "keep-newest",
+        //         "average_fill_price": "string",
+        //         "fill_fees": "string",
+        //         "size_filled": "string",
+        //         "created_at": "2019-08-24T14:15:22Z",
+        //         "epoch_timestamp": "2019-08-24T14:15:22Z",
+        //         "post_only": true,
+        //         "peg_price_type": "trailing-stop",
+        //         "peg_offset_value": "string",
+        //         "origin": "web",
+        //         "status": "pending"
+        //     }
+        //
+        return this.parseOrder(response);
+    }
+    async fetchOpenOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name coinlist#fetchOpenOrders
+         * @description fetch all unfilled currently open orders
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#list-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 order structures to retrieve (default 200, max 500)
+         * @param {object} [params] extra parameters specific to the coinlist api endpoint
+         * @param {int} [params.until] the latest time in ms to fetch entries for
+         * @returns {Order[]} a list of [order structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
+         */
+        await this.loadMarkets();
+        const request = {
+            'status': 'accepted',
+        };
+        return this.fetchOrders(symbol, since, limit, this.extend(request, params));
+    }
+    async fetchClosedOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name coinlist#fetchClosedOrders
+         * @description fetches information on multiple closed orders made by the user
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#list-orders
+         * @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 closed order structures to retrieve (default 200, max 500)
+         * @param {object} [params] extra parameters specific to the coinlist api endpoint
+         * @param {int} [params.until] the latest time in ms to fetch entries for
+         * @returns {Order[]} a list of [order structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
+         */
+        await this.loadMarkets();
+        const request = {
+            'status': 'done',
+        };
+        return this.fetchOrders(symbol, since, limit, this.extend(request, params));
+    }
+    async fetchCanceledOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name coinlist#fetchCanceledOrders
+         * @description fetches information on multiple canceled orders made by the user
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#list-orders
+         * @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 canceled order structures to retrieve (default 200, max 500)
+         * @param {object} [params] extra parameters specific to the coinlist api endpoint
+         * @param {int} [params.until] the latest time in ms to fetch entries for
+         * @returns {object} a list of [order structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
+         */
+        await this.loadMarkets();
+        const request = {
+            'status': 'canceled',
+        };
+        return this.fetchOrders(symbol, since, limit, this.extend(request, params));
+    }
+    async cancelAllOrders(symbol = undefined, params = {}) {
+        /**
+         * @method
+         * @name coinlist#cancelAllOrders
+         * @description cancel open orders of market
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#cancel-all-orders
+         * @param {string} symbol unified market symbol
+         * @param {object} [params] extra parameters specific to the coinlist api endpoint
+         * @returns {object[]} a list of [order structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
+         */
+        await this.loadMarkets();
+        let market = undefined;
+        const request = {};
+        if (symbol !== undefined) {
+            market = this.market(symbol);
+            request['symbol'] = market['id'];
+        }
+        const response = await this.privateDeleteV1Orders(this.extend(request, params));
+        //
+        //     {
+        //         message: 'Order cancellation request received.',
+        //         timestamp: '2023-10-26T10:29:28.652Z'
+        //     }
+        //
+        const orders = [response];
+        return this.parseOrders(orders, market);
+    }
+    async cancelOrder(id, symbol = undefined, params = {}) {
+        /**
+         * @method
+         * @name coinlist#cancelOrder
+         * @description cancels an open order
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#cancel-specific-order-by-id
+         * @param {string} id order id
+         * @param {string} symbol not used by coinlist cancelOrder ()
+         * @param {object} [params] extra parameters specific to the coinlist api endpoint
+         * @returns {object} An [order structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
+         */
+        await this.loadMarkets();
+        const request = {
+            'order_id': id,
+        };
+        const response = await this.privateDeleteV1OrdersOrderId(this.extend(request, params));
+        //
+        //     {
+        //         message: 'Cancel order request received.',
+        //         order_id: 'd36e7588-6525-485c-b768-8ad8b3f745f9',
+        //         timestamp: '2023-10-26T14:36:37.559Z'
+        //     }
+        //
+        return this.parseOrder(response);
+    }
+    async cancelOrders(ids, symbol = undefined, params = {}) {
+        /**
+         * @method
+         * @name coinlist#cancelOrders
+         * @description cancel multiple orders
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#cancel-specific-orders
+         * @param {string[]} ids order ids
+         * @param {string} symbol not used by coinlist cancelOrders ()
+         * @param {object} [params] extra parameters specific to the coinlist api endpoint
+         * @returns {object} an list of [order structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
+         */
+        await this.loadMarkets();
+        params = ids;
+        const response = await this.privateDeleteV1OrdersBulk(params);
+        return response;
+    }
+    async createOrder(symbol, type, side, amount, price = undefined, params = {}) {
+        /**
+         * @method
+         * @name coinlist#createOrder
+         * @description create a trade order
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#create-new-order
+         * @param {string} symbol unified symbol of the market to create an order in
+         * @param {string} type 'market' or 'limit' or 'stop_market' or 'stop_limit' or 'take_market' or 'take_limit'
+         * @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 coinlist api endpoint
+         * @param {bool} [params.postOnly] if true, the order will only be posted to the order book and not executed immediately (default false)
+         * @param {float} [params.triggerPrice] only for the 'stop_market', 'stop_limit', 'take_market' or 'take_limit' orders (the price at which an order is triggered)
+         * @param {string} [params.clientOrderId] client order id (default undefined)
+         * @returns {object} an [order structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
+         */
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const request = {
+            'symbol': market['id'],
+            'type': type,
+            'side': side,
+            'size': this.amountToPrecision(symbol, amount),
+        };
+        let isMarket = false;
+        if ((type === 'limit') || (type === 'stop_limit') || (type === 'take_limit')) {
+            if (price === undefined) {
+                throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.ArgumentsRequired(this.id + ' createOrder() requires a price argument for a ' + type + ' order');
+            }
+            request['price'] = this.priceToPrecision(symbol, price);
+        }
+        else {
+            isMarket = true;
+        }
+        let postOnly = undefined;
+        [postOnly, params] = this.handlePostOnly(isMarket, false, params);
+        if (postOnly) {
+            request['post_only'] = true;
+        }
+        const triggerPrice = this.safeNumberN(params, ['triggerPrice', 'trigger_price', 'stopPrice', 'stop_price']);
+        if (triggerPrice !== undefined) {
+            params = this.omit(params, ['triggerPrice', 'trigger_price', 'stopPrice']);
+            request['stop_price'] = this.priceToPrecision(symbol, triggerPrice);
+            if (type === 'market') {
+                request['type'] = 'stop_market';
+            }
+            else if (type === 'limit') {
+                request['type'] = 'stop_limit';
+            }
+        }
+        else if ((type === 'stop_market') || (type === 'stop_limit') || (type === 'take_market') || (type === 'take_limit')) {
+            throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.ArgumentsRequired(this.id + ' createOrder() requires a stopPrice parameter for stop-loss and take-profit orders');
+        }
+        const clientOrderId = this.safeString2(params, 'clientOrderId', 'client_id');
+        if (clientOrderId !== undefined) {
+            request['client_id'] = clientOrderId;
+            params = this.omit(params, ['clientOrderId', 'client_id']);
+        }
+        const response = await this.privatePostV1Orders(this.extend(request, params));
+        //
+        //     {
+        //         "message": "New order request received.",
+        //         "order": {
+        //             "symbol": "BTC-USDT",
+        //             "type": "market",
+        //             "side": "sell",
+        //             "size": "0.0003",
+        //             "order_id": "cad67c0f-9aec-4ac8-ac03-aaf5db299ff7",
+        //             "trader_id": "9c6f737e-a829-4843-87b1-b1ce86f2853b"
+        //         },
+        //         "timestamp": "2023-10-26T11:30:55.376Z"
+        //     }
+        //
+        const order = this.safeValue(response, 'order', {});
+        return this.parseOrder(order, market);
+    }
+    async editOrder(id, symbol, type, side, amount = undefined, price = undefined, params = {}) {
+        /**
+         * @method
+         * @name coinlist#editOrder
+         * @description create a trade order
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#modify-existing-order
+         * @param {string} symbol unified symbol of the market to create an order in
+         * @param {string} type 'market' or 'limit' or 'stop_market' or 'stop_limit' or 'take_market' or 'take_limit'
+         * @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 coinlist api endpoint
+         * @returns {object} an [order structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#order-structure}
+         */
+        await this.loadMarkets();
+        if (amount === undefined) {
+            throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.ArgumentsRequired(this.id + ' editOrder() requires an amount argument');
+        }
+        const market = this.market(symbol);
+        const request = {
+            'order_id': id,
+            'type': type,
+            'side': side,
+            'size': this.amountToPrecision(symbol, amount),
+        };
+        if (price !== undefined) {
+            request['price'] = this.priceToPrecision(symbol, price);
+        }
+        const response = await this.privatePatchV1OrdersOrderId(this.extend(request, params));
+        return this.parseOrder(response, market);
+    }
+    parseOrder(order, market = undefined) {
+        //
+        // fetchOrder
+        //     {
+        //         "order_id": "913ea6e7-9fc9-43fb-9db1-f195d3baa93f",
+        //         "price": "35800.00000000",
+        //         "stop_price":null,
+        //         "cost": "0.00000000",
+        //         "fill_fees": "0.00000000",
+        //         "trader_id": "9c6f737e-a829-4843-87b1-b1ce86f2853b",
+        //         "status": "canceled",
+        //         "epoch_timestamp": "2023-10-26T08:20:56.307Z",
+        //         "origin": "web",
+        //         "self_trade_prevention":null,
+        //         "client_id":null,
+        //         "symbol": "BTC-USDT",
+        //         "size": "0.0003",
+        //         "side": "sell",
+        //         "type": "limit",
+        //         "post_only":false,
+        //         "size_filled": "0.0000"
+        //     }
+        //
+        // fetchOrders
+        //     {
+        //         "order_id":"913ea6e7-9fc9-43fb-9db1-f195d3baa93f",
+        //         "price":"35800.00000000",
+        //         "stop_price":null,
+        //         "cost":"0.00000000",
+        //         "fill_fees":"0.00000000",
+        //         "trader_id":"9c6f737e-a829-4843-87b1-b1ce86f2853b",
+        //         "status":"accepted",
+        //         "epoch_timestamp":"2023-10-26T08:20:56.307Z",
+        //         "origin":"web",
+        //         "self_trade_prevention":null,
+        //         "client_id":null,
+        //         "created_at":"2023-10-26T08:20:56.307Z",
+        //         "symbol":"BTC-USDT",
+        //         "size":"0.0003",
+        //         "side":"sell",
+        //         "type":"limit",
+        //         "post_only":false,
+        //         "size_filled":"0.0000"
+        //     }
+        //
+        // createOrder
+        //     {
+        //         "symbol": "BTC-USDT",
+        //         "type": "market",
+        //         "side": "sell",
+        //         "size": "0.0003",
+        //         "order_id": "cad67c0f-9aec-4ac8-ac03-aaf5db299ff7",
+        //         "trader_id": "9c6f737e-a829-4843-87b1-b1ce86f2853b"
+        //     },
+        //
+        // cancelOrder
+        //     {
+        //         message: 'Cancel order request received.',
+        //         order_id: 'd36e7588-6525-485c-b768-8ad8b3f745f9',
+        //         timestamp: '2023-10-26T14:36:37.559Z'
+        //     }
+        //
+        // cancelOrders
+        //     {
+        //         message: 'Order cancellation request received.',
+        //         timestamp: '2023-10-26T10:29:28.652Z'
+        //     }
+        //
+        // cancelAllOrders
+        //     {
+        //         message: 'Order cancellation request received.',
+        //         timestamp: '2023-10-26T10:29:28.652Z'
+        //     }
+        //
+        const id = this.safeString(order, 'order_id');
+        const marketId = this.safeString(order, 'symbol');
+        market = this.safeMarket(marketId, market);
+        const clientOrderId = this.safeString(order, 'client_id');
+        let timestampString = this.safeString2(order, 'created_at', 'epoch_timestamp');
+        if (timestampString === undefined) {
+            timestampString = this.safeString(order, 'timestamp');
+        }
+        const timestamp = this.parse8601(timestampString);
+        const status = this.parseOrderStatus(this.safeString(order, 'status'));
+        const type = this.parseOrderType(this.safeString(order, 'type'));
+        const side = this.safeString(order, 'side');
+        const price = this.safeString(order, 'price');
+        const stopPrice = this.safeString(order, 'stop_price');
+        const average = this.safeString(order, 'average_fill_price'); // from documentation
+        const amount = this.safeString(order, 'size');
+        const filled = this.safeString(order, 'size_filled');
+        const feeCost = this.safeString(order, 'fill_fees');
+        const postOnly = this.safeValue(order, 'post_only');
+        let fee = undefined;
+        if (feeCost !== undefined) {
+            fee = {
+                'currency': market['quote'],
+                'cost': feeCost,
+                'rate': undefined,
+            };
+        }
+        return this.safeOrder({
+            'id': id,
+            'clientOrderId': clientOrderId,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'lastTradeTimestamp': undefined,
+            'status': status,
+            'symbol': market['symbol'],
+            'type': type,
+            'timeInForce': 'GTC',
+            'side': side,
+            'price': price,
+            'stopPrice': stopPrice,
+            'triggerPrice': stopPrice,
+            'average': average,
+            'amount': amount,
+            'cost': undefined,
+            'filled': filled,
+            'remaining': undefined,
+            'fee': fee,
+            'trades': undefined,
+            'info': order,
+            'postOnly': postOnly,
+        }, market);
+    }
+    parseOrderStatus(status) {
+        const statuses = {
+            'pending': 'open',
+            'accepted': 'open',
+            'rejected': 'rejected',
+            'done': 'closed',
+            'canceled': 'canceled',
+        };
+        return this.safeString(statuses, status, status);
+    }
+    parseOrderType(status) {
+        const statuses = {
+            'market': 'market',
+            'limit': 'limit',
+            'stop_market': 'market',
+            'stop_limit': 'limit',
+            'take_market': 'market',
+            'take_limit': 'limit',
+        };
+        return this.safeString(statuses, status, status);
+    }
+    async transfer(code, amount, fromAccount, toAccount, params = {}) {
+        /**
+         * @method
+         * @name coinlist#transfer
+         * @description transfer currency internally between wallets on the same account
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#transfer-funds-between-entities
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#transfer-funds-from-wallet-to-pro
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#transfer-funds-from-pro-to-wallet
+         * @param {string} code unified currency code
+         * @param {float} amount amount to transfer
+         * @param {string} fromAccount account to transfer from
+         * @param {string} toAccount account to transfer to
+         * @param {object} [params] extra parameters specific to the coinlist api endpoint
+         * @returns {object} a [transfer structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#transfer-structure}
+         */
+        await this.loadMarkets();
+        const currency = this.currency(code);
+        amount = this.currencyToPrecision(code, amount);
+        const request = {
+            'asset': currency['id'],
+            'amount': amount,
+        };
+        const accountsByType = this.safeValue(this.options, 'accountsByType', {});
+        const fromAcc = this.safeString(accountsByType, fromAccount, fromAccount);
+        const toAcc = this.safeString(accountsByType, toAccount, toAccount);
+        let response = undefined;
+        if ((fromAcc === 'funding') && (toAcc === 'trading')) {
+            response = await this.privatePostV1TransfersFromWallet(this.extend(request, params));
+        }
+        else if ((fromAcc === 'trading') && (toAcc === 'funding')) {
+            response = await this.privatePostV1TransfersToWallet(this.extend(request, params));
+        }
+        else {
+            request['from_trader_id'] = fromAcc;
+            request['to_trader_id'] = toAcc;
+            response = await this.privatePostV1TransfersInternalTransfer(this.extend(request, params));
+        }
+        //
+        // privatePostV1TransfersInternalTransfer
+        //     {
+        //         "from_trader_id": "1f494ace-b3ed-4324-b202-55526ed06381",
+        //         "to_trader_id": "d32c7a40-cc24-44b0-8597-f9edb3da989f",
+        //         "asset": "string",
+        //         "amount": "string"
+        //     }
+        //
+        // privatePostV1TransfersFromWallet, privatePostV1TransfersToWallet
+        //     {
+        //         "transfer_id": "bb34f528-d9b0-47c6-b11f-4d4840b86ee3"
+        //     }
+        //
+        const transfer = this.parseTransfer(response, currency);
+        return transfer;
+    }
+    async fetchTransfers(code = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name coinlist#fetchTransfers
+         * @description fetch a history of internal transfers between CoinList.co and CoinList Pro. It does not return external deposits or withdrawals
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#list-transfers
+         * @param {string} code unified currency code
+         * @param {int} [since] the earliest time in ms to fetch transfers for
+         * @param {int} [limit] the maximum number of transfer structures to retrieve (default 200, max 500)
+         * @param {object} [params] extra parameters specific to the coinlist api endpoint
+         * @param {int} [params.until] the latest time in ms to fetch entries for
+         * @returns {object[]} a list of [transfer structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#transfer-structure}
+         */
+        await this.loadMarkets();
+        let currency = undefined;
+        if (code !== undefined) {
+            currency = this.currency(code);
+        }
+        const request = {};
+        if (since !== undefined) {
+            request['start_time'] = this.iso8601(since);
+        }
+        if (limit !== undefined) {
+            request['count'] = limit;
+        }
+        const until = this.safeInteger2(params, 'till', 'until');
+        if (until !== undefined) {
+            params = this.omit(params, ['till', 'until']);
+            request['end_time'] = this.iso8601(until);
+        }
+        const response = await this.privateGetV1Transfers(this.extend(request, params));
+        //
+        //     {
+        //         "transfers": [
+        //             {
+        //                 "transfer_id": "2c02db25-e8f2-4271-8222-e110bfd0aa2a",
+        //                 "created_at": "2023-10-20T13:15:37.000Z",
+        //                 "confirmed_at": "2023-10-20T13:15:37.000Z",
+        //                 "asset": "ETH",
+        //                 "amount": "0.010000000000000000",
+        //                 "status": "confirmed"
+        //             },
+        //             {
+        //                 "transfer_id": "890694db-156c-4e93-a3ef-4db61685aca7",
+        //                 "created_at": "2023-10-26T14:32:22.000Z",
+        //                 "confirmed_at": "2023-10-26T14:32:22.000Z",
+        //                 "asset": "USD",
+        //                 "amount": "-3.00",
+        //                 "status": "confirmed"
+        //             }
+        //         ]
+        //     }
+        //
+        const transfers = this.safeValue(response, 'transfers', []);
+        return this.parseTransfers(transfers, currency, since, limit);
+    }
+    parseTransfer(transfer, currency = undefined) {
+        //
+        // fetchTransfers
+        //     {
+        //         "transfer_id": "890694db-156c-4e93-a3ef-4db61685aca7",
+        //         "created_at": "2023-10-26T14:32:22.000Z",
+        //         "confirmed_at": "2023-10-26T14:32:22.000Z",
+        //         "asset": "USD",
+        //         "amount": "-3.00",
+        //         "status": "confirmed"
+        //     }
+        //
+        // transfer - privatePostV1TransfersInternalTransfer
+        //     {
+        //         "from_trader_id": "1f494ace-b3ed-4324-b202-55526ed06381",
+        //         "to_trader_id": "d32c7a40-cc24-44b0-8597-f9edb3da989f",
+        //         "asset": "string",
+        //         "amount": "string"
+        //     }
+        //
+        // transfer - privatePostV1TransfersFromWallet, privatePostV1TransfersToWallet
+        //     {
+        //         "transfer_id": "bb34f528-d9b0-47c6-b11f-4d4840b86ee3"
+        //     }
+        //
+        const currencyId = this.safeString(transfer, 'asset');
+        const confirmedAt = this.safeString(transfer, 'confirmed_at');
+        const timetstamp = this.parse8601(confirmedAt);
+        const status = this.safeString(transfer, 'status');
+        let amountString = this.safeString(transfer, 'amount');
+        let fromAccount = undefined;
+        let toAccount = undefined;
+        let amount = undefined;
+        if (amountString !== undefined) {
+            const amountIsNegative = _base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise.stringLt */ .O.stringLt(amountString, '0');
+            if (amountIsNegative) {
+                fromAccount = 'trading';
+                toAccount = 'funding';
+                amountString = _base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise.stringNeg */ .O.stringNeg(amountString);
+            }
+            else {
+                fromAccount = 'funding';
+                toAccount = 'trading';
+            }
+            amount = this.parseNumber(amountString);
+        }
+        return {
+            'info': transfer,
+            'id': this.safeString(transfer, 'transfer_id'),
+            'timestamp': timetstamp,
+            'datetime': this.iso8601(timetstamp),
+            'currency': this.safeCurrencyCode(currencyId, currency),
+            'amount': amount,
+            'fromAccount': fromAccount,
+            'toAccount': toAccount,
+            'status': this.parseTransferStatus(status),
+        };
+    }
+    parseTransferStatus(status) {
+        const statuses = {
+            'confirmed': 'ok',
+        };
+        return this.safeString(statuses, status, status);
+    }
+    async fetchDepositsWithdrawals(code = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name coinlist#fetchDepositsWithdrawals
+         * @description fetch history of deposits and withdrawals from external wallets and between CoinList Pro trading account and CoinList wallet
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#get-coinlist-wallet-ledger
+         * @param {string} [code] unified currency code for the currency of the deposit/withdrawals
+         * @param {int} [since] timestamp in ms of the earliest deposit/withdrawal
+         * @param {int} [limit] max number of deposit/withdrawals to return (default 200, max 500)
+         * @param {object} [params] extra parameters specific to the coinlist api endpoint
+         * @returns {object} a list of [transaction structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#transaction-structure}
+         */
+        if (code === undefined) {
+            throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.ArgumentsRequired(this.id + ' fetchDepositsWithdrawals() requires a code argument');
+        }
+        const traderId = this.safeString2(params, 'trader_id', 'traderId');
+        if (traderId === undefined) {
+            throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.ArgumentsRequired(this.id + ' fetchDepositsWithdrawals() requires a traderId argument in the params');
+        }
+        await this.loadMarkets();
+        const currency = this.currency(code);
+        const request = {
+            'asset': currency['id'],
+            'trader_id': traderId,
+        };
+        if (limit !== undefined) {
+            request['count'] = limit;
+        }
+        params = this.omit(params, ['trader_id', 'traderId']);
+        const response = await this.privateGetV1AccountsTraderIdWalletLedger(this.extend(request, params));
+        //
+        //     [
+        //         {
+        //             "id": "2c02db25-e8f2-4271-8222-e110bfd0aa2a",
+        //             "asset": "ETH",
+        //             "amount": "0.01",
+        //             "created_at": "2023-10-20T13:15:37.000Z",
+        //             "description": "Transfer to CoinList Pro",
+        //             "type": "PRO_TRANSFER",
+        //             "delta": "-0.010000000000000000"
+        //         },
+        //         {
+        //             "id": "7139384d-6cec-479e-a19c-d498647ccb47",
+        //             "asset": "ETH",
+        //             "amount": "0.01",
+        //             "created_at": "2023-10-20T13:10:55.000Z",
+        //             "description": "CRYPTO_DEPOSIT",
+        //             "type": "CRYPTO_DEPOSIT",
+        //             "delta": "0.010000000000000000"
+        //         },
+        //
+        //         ...
+        //
+        //         {
+        //             "id": "91bbbb22-5ede-4e9a-81ef-3f9318aa83d2",
+        //             "asset": "USDT",
+        //             "amount": "4.169654",
+        //             "withdrawal_fee_amount": "8.830346000000000000",
+        //             "created_at": "2023-10-27T16:14:11.000Z",
+        //             "description": "CRYPTO_WITHDRAWAL",
+        //             "type": "CRYPTO_WITHDRAWAL",
+        //             "delta": "-4.169654000000000000"
+        //         },
+        //         {
+        //             "id": "830261bd-cda9-401f-b6df-105f4da3b37c",
+        //             "asset": "USDT",
+        //             "amount": "13",
+        //             "created_at": "2023-10-27T14:52:05.000Z",
+        //             "description": "Transfer from CoinList Pro",
+        //             "type": "PRO_TRANSFER",
+        //             "delta": "13.000000000000000000"
+        //         }
+        //     ]
+        //
+        // coinlist returns both internal transfers and blockchain transactions
+        return this.parseTransactions(response, currency, since, limit);
+    }
+    async withdraw(code, amount, address, tag = undefined, params = {}) {
+        /**
+         * @method
+         * @name coinlist#withdraw
+         * @description request a withdrawal from CoinList wallet. (Disabled by default. Contact CoinList to apply for an exception.)
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#request-withdrawal-from-wallet
+         * @param {string} code unified currency code
+         * @param {float} amount the amount to withdraw
+         * @param {string} address the address to withdraw to
+         * @param {string} tag
+         * @param {object} [params] extra parameters specific to the coinlist api endpoint
+         * @returns {object} a [transaction structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#transaction-structure}
+         */
+        await this.loadMarkets();
+        const currency = this.currency(code);
+        const request = {
+            'asset': currency['id'],
+            'amount': this.currencyToPrecision(code, amount),
+            'destination_address': address,
+        };
+        const response = await this.privatePostV1TransfersWithdrawalRequest(this.extend(request, params));
+        //
+        //     {
+        //         "transfer_id": "d4a2d8dd-7def-4545-a062-761683b9aa05"
+        //     }
+        //
+        const data = this.safeValue(response, 'data', {});
+        return this.parseTransaction(data, currency);
+    }
+    parseTransaction(transaction, currency = undefined) {
+        // withdraw
+        //
+        //     {
+        //         "transfer_id": "d4a2d8dd-7def-4545-a062-761683b9aa05"
+        //     }
+        //
+        // fetchDepositsWithdrawals
+        //     {
+        //         "id": "91bbbb22-5ede-4e9a-81ef-3f9318aa83d2",
+        //         "asset": "USDT",
+        //         "amount": "4.169654",
+        //         "withdrawal_fee_amount": "8.830346000000000000",
+        //         "created_at": "2023-10-27T16:14:11.000Z",
+        //         "description": "CRYPTO_WITHDRAWAL",
+        //         "type": "CRYPTO_WITHDRAWAL",
+        //         "delta": "-4.169654000000000000"
+        //     },
+        //
+        const currencyId = this.safeString(transaction, 'asset');
+        const code = this.safeCurrencyCode(currencyId, currency);
+        const id = this.safeString2(transaction, 'id', 'transfer_id');
+        const amount = this.safeNumber(transaction, 'amount');
+        const timestamp = this.parse8601(this.safeString(transaction, 'created_at'));
+        let type = this.safeString(transaction, 'type', undefined);
+        if (type === undefined) {
+            type = 'withdrawal'; // undefined only in withdraw() method
+        }
+        else {
+            type = this.parseTransactionType(type);
+        }
+        let fee = undefined;
+        const feeCost = this.safeString(transaction, 'withdrawal_fee_amount');
+        if (feeCost !== undefined) {
+            fee = {
+                'cost': feeCost,
+                'currency': code,
+            };
+        }
+        return {
+            'info': transaction,
+            'id': id,
+            'txid': undefined,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'network': undefined,
+            'addressFrom': undefined,
+            'address': undefined,
+            'addressTo': undefined,
+            'tagFrom': undefined,
+            'tag': undefined,
+            'tagTo': undefined,
+            'type': type,
+            'amount': amount,
+            'currency': code,
+            'status': undefined,
+            'updated': undefined,
+            'fee': fee,
+        };
+    }
+    parseTransactionType(type) {
+        const types = {
+            'CRYPTO_DEPOSIT': 'deposit',
+            'CRYPTO_WITHDRAWAL': 'withdrawal',
+            'PRO_TRANSFER': 'transfer',
+        };
+        return this.safeString(types, type, type);
+    }
+    async fetchLedger(code = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name coinlist#fetchLedger
+         * @description fetch the history of changes, actions done by the user or operations that altered balance of the user
+         * @see https://trade-docs.coinlist.co/?javascript--nodejs#get-account-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 200, max 500)
+         * @param {object} [params] extra parameters specific to the coinlist api endpoint
+         * @param {int} [params.until] the latest time in ms to fetch entries for
+         * @returns {object} a [ledger structure]{@link https://github.com/ccxt/ccxt/wiki/Manual#ledger-structure}
+         */
+        const traderId = this.safeString2(params, 'trader_id', 'traderId');
+        if (traderId === undefined) {
+            throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.ArgumentsRequired(this.id + ' fetchLedger() requires a traderId argument in the params');
+        }
+        await this.loadMarkets();
+        const request = {
+            'trader_id': traderId,
+        };
+        let currency = undefined;
+        if (code !== undefined) {
+            currency = this.currency(code);
+        }
+        if (since !== undefined) {
+            request['start_time'] = this.iso8601(since);
+        }
+        if (limit !== undefined) {
+            request['count'] = limit;
+        }
+        const until = this.safeInteger2(params, 'till', 'until');
+        if (until !== undefined) {
+            params = this.omit(params, ['till', 'until']);
+            request['end_time'] = this.iso8601(until);
+        }
+        params = this.omit(params, ['trader_id', 'traderId']);
+        const response = await this.privateGetV1AccountsTraderIdLedger(this.extend(request, params));
+        //
+        //     {
+        //         transactions: [
+        //             {
+        //                 transaction_id: '0288634e-49bd-494d-b04a-18fd1832d394',
+        //                 transaction_type: 'XFER',
+        //                 type: 'deposit',
+        //                 asset: 'ETH',
+        //                 symbol: null,
+        //                 amount: '0.010000000000000000',
+        //                 details: null,
+        //                 created_at: '2023-10-20T13:15:39.443Z'
+        //             },
+        //             {
+        //                 transaction_id: '47a45928-abcd-4c12-8bd6-587c3028025f',
+        //                 transaction_type: 'SWAP',
+        //                 type: 'atomic token swap',
+        //                 asset: 'USDT',
+        //                 symbol: 'ETH-USDT',
+        //                 amount: '1.447947',
+        //                 details: null,
+        //                 created_at: '2023-10-20T13:16:30.373Z'
+        //             },
+        //             {
+        //                 transaction_id: '1ffe3a54-916e-41f0-b957-3a01309eb009',
+        //                 transaction_type: 'FEE',
+        //                 type: 'fee',
+        //                 asset: 'USDT',
+        //                 symbol: 'ETH-USDT',
+        //                 amount: '-0.006516',
+        //                 details: {
+        //                     fee_details: [
+        //                         {
+        //                             insurance_fee: '0',
+        //                             order_id: '39911d5f-c789-4a7d-ad34-820a804d1da6',
+        //                             fee_type: 'taker',
+        //                             fee_currency: 'USDT'
+        //                         }
+        //                     ]
+        //                 },
+        //                 created_at: '2023-10-20T13:16:30.373Z'
+        //             },
+        //             {
+        //                 transaction_id: '3930e8a3-2218-481f-8c3c-2219287e205e',
+        //                 transaction_type: 'SWAP',
+        //                 type: 'atomic token swap',
+        //                 asset: 'ETH',
+        //                 symbol: 'ETH-USDT',
+        //                 amount: '-0.000900000000000000',
+        //                 details: null,
+        //                 created_at: '2023-10-20T13:16:30.373Z'
+        //             },
+        //             {
+        //                 transaction_id: 'a6c65cb3-95d0-44e2-8202-f70581d6e55c',
+        //                 transaction_type: 'XFER',
+        //                 type: 'withdrawal',
+        //                 asset: 'USD',
+        //                 symbol: null,
+        //                 amount: '-3.00',
+        //                 details: null,
+        //                 created_at: '2023-10-26T14:32:24.887Z'
+        //             }
+        //         ]
+        //     }
+        //
+        const ledger = this.safeValue(response, 'transactions', []);
+        return this.parseLedger(ledger, currency, since, limit);
+    }
+    parseLedgerEntry(item, currency = undefined) {
+        //
+        // deposit transaction from wallet (funding) to pro (trading)
+        //     {
+        //         transaction_id: '0288634e-49bd-494d-b04a-18fd1832d394',
+        //         transaction_type: 'XFER',
+        //         type: 'deposit',
+        //         asset: 'ETH',
+        //         symbol: null,
+        //         amount: '0.010000000000000000',
+        //         details: null,
+        //         created_at: '2023-10-20T13:15:39.443Z'
+        //     }
+        //
+        // withdrawal transaction from pro (trading) to wallet (funding)
+        //     {
+        //         transaction_id: 'a6c65cb3-95d0-44e2-8202-f70581d6e55c',
+        //         transaction_type: 'XFER',
+        //         type: 'withdrawal',
+        //         asset: 'USD',
+        //         symbol: null,
+        //         amount: '-3.00',
+        //         details: null,
+        //         created_at: '2023-10-26T14:32:24.887Z'
+        //     }
+        //
+        // sell trade
+        //     {
+        //         transaction_id: '47a45928-abcd-4c12-8bd6-587c3028025f',
+        //         transaction_type: 'SWAP',
+        //         type: 'atomic token swap',
+        //         asset: 'USDT',
+        //         symbol: 'ETH-USDT',
+        //         amount: '1.447947',
+        //         details: null,
+        //         created_at: '2023-10-20T13:16:30.373Z'
+        //     }
+        //
+        // buy trade
+        //     {
+        //         transaction_id: '46d20a93-45c4-4441-a238-f89602eb8c8c',
+        //         transaction_type: 'SWAP',
+        //         type: 'atomic token swap',
+        //         asset: 'ETH',
+        //         symbol: 'ETH-USDT',
+        //         amount: '0.000800000000000000',
+        //         details: null,
+        //         created_at: '2023-10-20T13:22:14.256Z'
+        //     },
+        //
+        //  fee
+        //     {
+        //         transaction_id: '57fd526c-36b1-4721-83ce-42aadcb1e953',
+        //         transaction_type: 'FEE',
+        //         type: 'fee',
+        //         asset: 'USDT',
+        //         symbol: 'BTC-USDT',
+        //         amount: '-0.047176',
+        //         details: {
+        //             fee_details: [
+        //                 {
+        //                     insurance_fee: '0',
+        //                     order_id: 'c0bc33cd-eeb9-40a0-ab5f-2d99f323ef58',
+        //                     fee_type: 'taker',
+        //                     fee_currency: 'USDT'
+        //                 }
+        //             ]
+        //         },
+        //         created_at: '2023-10-25T16:46:24.294Z'
+        //     }
+        //
+        const id = this.safeString(item, 'transaction_id');
+        const createdAt = this.safeString(item, 'created_at');
+        const timestamp = this.parse8601(createdAt);
+        let amount = this.safeString(item, 'amount');
+        const amountIsNegative = _base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise.stringLt */ .O.stringLt(amount, '0');
+        let direction = undefined;
+        if (amountIsNegative) {
+            direction = 'out';
+            amount = _base_Precise_js__WEBPACK_IMPORTED_MODULE_3__/* .Precise.stringNeg */ .O.stringNeg(amount);
+        }
+        else {
+            direction = 'in';
+        }
+        const currencyId = this.safeString(item, 'asset');
+        const code = this.safeCurrencyCode(currencyId, currency);
+        const type = this.parseLedgerEntryType(this.safeString(item, 'type'));
+        return {
+            'info': item,
+            'id': id,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'direction': direction,
+            'account': 'trading',
+            'referenceId': undefined,
+            'referenceAccount': undefined,
+            'type': type,
+            'currency': code,
+            'amount': this.parseNumber(amount),
+            'before': undefined,
+            'after': undefined,
+            'status': 'ok',
+            'fee': undefined,
+        };
+    }
+    parseLedgerEntryType(type) {
+        const types = {
+            'atomic token swap': 'trade',
+            'fee': 'fee',
+            'deposit': 'transfer',
+            'withdrawal': 'transfer',
+        };
+        return this.safeString(types, type, type);
+    }
+    sign(path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
+        const request = this.omit(params, this.extractParams(path));
+        const endpoint = '/' + this.implodeParams(path, params);
+        let url = this.urls['api'][api] + endpoint;
+        const query = this.urlencode(request);
+        if (api === 'private') {
+            this.checkRequiredCredentials();
+            const timestamp = this.seconds().toString();
+            let auth = timestamp + method + endpoint;
+            const isBulk = Array.isArray(params);
+            if ((method === 'POST') || (method === 'PATCH') || isBulk) {
+                body = this.json(request);
+                auth += body;
+            }
+            else if (query.length !== 0) {
+                auth += '?' + query;
+                url += '?' + query;
+            }
+            const signature = this.hmac(this.encode(auth), this.base64ToBinary(this.secret), _static_dependencies_noble_hashes_sha256_js__WEBPACK_IMPORTED_MODULE_4__/* .sha256 */ .J, 'base64');
+            headers = {
+                'CL-ACCESS-KEY': this.apiKey,
+                'CL-ACCESS-SIG': signature,
+                'CL-ACCESS-TIMESTAMP': timestamp,
+                'Content-Type': 'application/json',
+            };
+        }
+        else if (query.length !== 0) {
+            url += '?' + query;
+        }
+        return { 'url': url, 'method': method, 'body': body, 'headers': headers };
+    }
+    handleErrors(code, reason, url, method, headers, body, response, requestHeaders, requestBody) {
+        if (response === undefined) {
+            // In some cases the exchange returns 202 Accepted for bad orders.
+            // The body of that response contains order_id of the order.
+            // Some bad orders will get status 'rejected' and could be fetched later (by using fetchOrders() or fetchOrder(order_id)).
+            // While others don't get any status, they simply disappear, but the response is still 202 Accepted and contains their order_id.
+            // When using fechOrder(order_id) for such disappeared orders, the exchange returns an empty response with code 404.
+            if ((code === 404) && (url.indexOf('/orders/') >= 0) && (method === 'GET')) {
+                const parts = url.split('/orders/');
+                const orderId = this.safeString(parts, 1);
+                throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.OrderNotFound(this.id + ' order ' + orderId + ' not found (or rejected on the exchange side)');
+            }
+            return undefined;
+        }
+        const responseCode = this.safeString(response, 'status');
+        const messageCode = this.safeString(response, 'message_code');
+        if ((messageCode !== undefined) || ((responseCode !== undefined) && (code !== 200) && (code !== 202) && (responseCode !== '200') && (responseCode !== '202'))) {
+            const feedback = this.id + ' ' + body;
+            const message = this.safeString(response, 'message');
+            this.throwBroadlyMatchedException(this.exceptions['broad'], message, feedback);
+            this.throwExactlyMatchedException(this.exceptions['exact'], messageCode, feedback);
+            throw new _base_errors_js__WEBPACK_IMPORTED_MODULE_2__.ExchangeError(feedback);
+        }
+        return undefined;
+    }
+}
+
+
 /***/ }),
 
 /***/ 9816:
@@ -211171,7 +213654,7 @@ class bitrue extends _bitrue_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z
 
 /***/ }),
 
-/***/ 3623:
+/***/ 2317:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
@@ -247468,6 +249951,7 @@ class probit extends _abstract_probit_js__WEBPACK_IMPORTED_MODULE_0__/* ["defaul
          * @param {string} code unified currency code
          * @param {int} [since] the earliest time in ms to fetch transactions for
          * @param {int} [limit] the maximum number of transaction structures to retrieve
+         * @param {int} [params.until] the latest time in ms to fetch transactions for
          * @param {object} [params] extra parameters specific to the probit api endpoint
          * @returns {object[]} a list of [transaction structures]{@link https://github.com/ccxt/ccxt/wiki/Manual#transaction-structure}
          */
@@ -247481,6 +249965,17 @@ class probit extends _abstract_probit_js__WEBPACK_IMPORTED_MODULE_0__/* ["defaul
         if (since !== undefined) {
             request['start_time'] = this.iso8601(since);
         }
+        else {
+            request['start_time'] = this.iso8601(1);
+        }
+        const until = this.safeInteger2(params, 'till', 'until');
+        if (until !== undefined) {
+            request['end_time'] = this.iso8601(until);
+            params = this.omit(params, ['until', 'till']);
+        }
+        else {
+            request['end_time'] = this.iso8601(this.milliseconds());
+        }
         if (limit !== undefined) {
             request['limit'] = limit;
         }
@@ -247516,7 +250011,29 @@ class probit extends _abstract_probit_js__WEBPACK_IMPORTED_MODULE_0__/* ["defaul
         return this.parseTransactions(data, currency, since, limit);
     }
     parseTransaction(transaction, currency = undefined) {
+        //
+        //     {
+        //         "id": "01211d4b-0e68-41d6-97cb-298bfe2cab67",
+        //         "type": "deposit",
+        //         "status": "done",
+        //         "amount": "0.01",
+        //         "address": "0x9e7430fc0bdd14745bd00a1b92ed25133a7c765f",
+        //         "time": "2023-06-14T12:03:11.000Z",
+        //         "hash": "0x0ff5bedc9e378f9529acc6b9840fa8c2ef00fd0275e0bac7fa0589a9b5d1712e",
+        //         "currency_id": "ETH",
+        //         "confirmations":0,
+        //         "fee": "0",
+        //         "destination_tag": null,
+        //         "platform_id": "ETH",
+        //         "fee_currency_id": "ETH",
+        //         "payment_service_name":null,
+        //         "payment_service_display_name":null,
+        //         "crypto":null
+        //     }
+        //
         const id = this.safeString(transaction, 'id');
+        const networkId = this.safeString(transaction, 'platform_id');
+        const networkCode = this.networkIdToCode(networkId);
         const amount = this.safeNumber(transaction, 'amount');
         const address = this.safeString(transaction, 'address');
         const tag = this.safeString(transaction, 'destination_tag');
@@ -247538,7 +250055,7 @@ class probit extends _abstract_probit_js__WEBPACK_IMPORTED_MODULE_0__/* ["defaul
             'id': id,
             'currency': code,
             'amount': amount,
-            'network': undefined,
+            'network': networkCode,
             'addressFrom': undefined,
             'address': address,
             'addressTo': address,
@@ -281450,39 +283967,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_168__.AccountNotEnabled),
-/* harmony export */   "AccountSuspended": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.AccountSuspended),
-/* harmony export */   "AddressPending": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.AddressPending),
-/* harmony export */   "ArgumentsRequired": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.ArgumentsRequired),
-/* harmony export */   "AuthenticationError": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.AuthenticationError),
-/* harmony export */   "BadRequest": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.BadRequest),
-/* harmony export */   "BadResponse": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.BadResponse),
-/* harmony export */   "BadSymbol": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.BadSymbol),
-/* harmony export */   "BaseError": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.BaseError),
-/* harmony export */   "CancelPending": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.CancelPending),
-/* harmony export */   "DDoSProtection": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.DDoSProtection),
-/* harmony export */   "DuplicateOrderId": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.DuplicateOrderId),
+/* harmony export */   "AccountNotEnabled": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.AccountNotEnabled),
+/* harmony export */   "AccountSuspended": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.AccountSuspended),
+/* harmony export */   "AddressPending": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.AddressPending),
+/* harmony export */   "ArgumentsRequired": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.ArgumentsRequired),
+/* harmony export */   "AuthenticationError": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.AuthenticationError),
+/* harmony export */   "BadRequest": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.BadRequest),
+/* harmony export */   "BadResponse": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.BadResponse),
+/* harmony export */   "BadSymbol": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.BadSymbol),
+/* harmony export */   "BaseError": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.BaseError),
+/* harmony export */   "CancelPending": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.CancelPending),
+/* harmony export */   "DDoSProtection": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.DDoSProtection),
+/* harmony export */   "DuplicateOrderId": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.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_168__.ExchangeError),
-/* harmony export */   "ExchangeNotAvailable": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.ExchangeNotAvailable),
-/* harmony export */   "InsufficientFunds": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.InsufficientFunds),
-/* harmony export */   "InvalidAddress": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.InvalidAddress),
-/* harmony export */   "InvalidNonce": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.InvalidNonce),
-/* harmony export */   "InvalidOrder": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.InvalidOrder),
-/* harmony export */   "MarginModeAlreadySet": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.MarginModeAlreadySet),
-/* harmony export */   "NetworkError": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.NetworkError),
-/* harmony export */   "NoChange": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.NoChange),
-/* harmony export */   "NotSupported": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.NotSupported),
-/* harmony export */   "NullResponse": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.NullResponse),
-/* harmony export */   "OnMaintenance": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.OnMaintenance),
-/* harmony export */   "OrderImmediatelyFillable": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.OrderImmediatelyFillable),
-/* harmony export */   "OrderNotCached": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.OrderNotCached),
-/* harmony export */   "OrderNotFillable": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.OrderNotFillable),
-/* harmony export */   "OrderNotFound": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.OrderNotFound),
-/* harmony export */   "PermissionDenied": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.PermissionDenied),
-/* harmony export */   "Precise": () => (/* reexport safe */ _src_base_Precise_js__WEBPACK_IMPORTED_MODULE_166__.O),
-/* harmony export */   "RateLimitExceeded": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.RateLimitExceeded),
-/* harmony export */   "RequestTimeout": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__.RequestTimeout),
+/* harmony export */   "ExchangeError": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.ExchangeError),
+/* harmony export */   "ExchangeNotAvailable": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.ExchangeNotAvailable),
+/* harmony export */   "InsufficientFunds": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.InsufficientFunds),
+/* harmony export */   "InvalidAddress": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.InvalidAddress),
+/* harmony export */   "InvalidNonce": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.InvalidNonce),
+/* harmony export */   "InvalidOrder": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.InvalidOrder),
+/* harmony export */   "MarginModeAlreadySet": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.MarginModeAlreadySet),
+/* harmony export */   "NetworkError": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.NetworkError),
+/* harmony export */   "NoChange": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.NoChange),
+/* harmony export */   "NotSupported": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.NotSupported),
+/* harmony export */   "NullResponse": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.NullResponse),
+/* harmony export */   "OnMaintenance": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.OnMaintenance),
+/* harmony export */   "OrderImmediatelyFillable": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.OrderImmediatelyFillable),
+/* harmony export */   "OrderNotCached": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.OrderNotCached),
+/* harmony export */   "OrderNotFillable": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.OrderNotFillable),
+/* harmony export */   "OrderNotFound": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.OrderNotFound),
+/* harmony export */   "PermissionDenied": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.PermissionDenied),
+/* harmony export */   "Precise": () => (/* reexport safe */ _src_base_Precise_js__WEBPACK_IMPORTED_MODULE_167__.O),
+/* harmony export */   "RateLimitExceeded": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.RateLimitExceeded),
+/* harmony export */   "RequestTimeout": () => (/* reexport safe */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__.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),
@@ -281529,76 +284046,77 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   "coincheck": () => (/* reexport safe */ _src_coincheck_js__WEBPACK_IMPORTED_MODULE_44__.Z),
 /* harmony export */   "coinex": () => (/* reexport safe */ _src_coinex_js__WEBPACK_IMPORTED_MODULE_45__.Z),
 /* harmony export */   "coinfalcon": () => (/* reexport safe */ _src_coinfalcon_js__WEBPACK_IMPORTED_MODULE_46__.Z),
-/* harmony export */   "coinmate": () => (/* reexport safe */ _src_coinmate_js__WEBPACK_IMPORTED_MODULE_47__.Z),
-/* harmony export */   "coinone": () => (/* reexport safe */ _src_coinone_js__WEBPACK_IMPORTED_MODULE_48__.Z),
-/* harmony export */   "coinsph": () => (/* reexport safe */ _src_coinsph_js__WEBPACK_IMPORTED_MODULE_49__.Z),
-/* harmony export */   "coinspot": () => (/* reexport safe */ _src_coinspot_js__WEBPACK_IMPORTED_MODULE_50__.Z),
-/* harmony export */   "cryptocom": () => (/* reexport safe */ _src_cryptocom_js__WEBPACK_IMPORTED_MODULE_51__.Z),
-/* harmony export */   "currencycom": () => (/* reexport safe */ _src_currencycom_js__WEBPACK_IMPORTED_MODULE_52__.Z),
+/* harmony export */   "coinlist": () => (/* reexport safe */ _src_coinlist_js__WEBPACK_IMPORTED_MODULE_47__.Z),
+/* harmony export */   "coinmate": () => (/* reexport safe */ _src_coinmate_js__WEBPACK_IMPORTED_MODULE_48__.Z),
+/* harmony export */   "coinone": () => (/* reexport safe */ _src_coinone_js__WEBPACK_IMPORTED_MODULE_49__.Z),
+/* harmony export */   "coinsph": () => (/* reexport safe */ _src_coinsph_js__WEBPACK_IMPORTED_MODULE_50__.Z),
+/* harmony export */   "coinspot": () => (/* reexport safe */ _src_coinspot_js__WEBPACK_IMPORTED_MODULE_51__.Z),
+/* harmony export */   "cryptocom": () => (/* reexport safe */ _src_cryptocom_js__WEBPACK_IMPORTED_MODULE_52__.Z),
+/* harmony export */   "currencycom": () => (/* reexport safe */ _src_currencycom_js__WEBPACK_IMPORTED_MODULE_53__.Z),
 /* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__),
-/* harmony export */   "delta": () => (/* reexport safe */ _src_delta_js__WEBPACK_IMPORTED_MODULE_53__.Z),
-/* harmony export */   "deribit": () => (/* reexport safe */ _src_deribit_js__WEBPACK_IMPORTED_MODULE_54__.Z),
-/* harmony export */   "digifinex": () => (/* reexport safe */ _src_digifinex_js__WEBPACK_IMPORTED_MODULE_55__.Z),
-/* harmony export */   "errors": () => (/* reexport module object */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__),
+/* harmony export */   "delta": () => (/* reexport safe */ _src_delta_js__WEBPACK_IMPORTED_MODULE_54__.Z),
+/* harmony export */   "deribit": () => (/* reexport safe */ _src_deribit_js__WEBPACK_IMPORTED_MODULE_55__.Z),
+/* harmony export */   "digifinex": () => (/* reexport safe */ _src_digifinex_js__WEBPACK_IMPORTED_MODULE_56__.Z),
+/* harmony export */   "errors": () => (/* reexport module object */ _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__),
 /* harmony export */   "exchanges": () => (/* binding */ exchanges),
-/* harmony export */   "exmo": () => (/* reexport safe */ _src_exmo_js__WEBPACK_IMPORTED_MODULE_56__.Z),
-/* harmony export */   "fmfwio": () => (/* reexport safe */ _src_fmfwio_js__WEBPACK_IMPORTED_MODULE_57__.Z),
-/* harmony export */   "functions": () => (/* reexport module object */ _src_base_functions_js__WEBPACK_IMPORTED_MODULE_167__),
-/* harmony export */   "gate": () => (/* reexport safe */ _src_gate_js__WEBPACK_IMPORTED_MODULE_58__.Z),
-/* harmony export */   "gateio": () => (/* reexport safe */ _src_gateio_js__WEBPACK_IMPORTED_MODULE_59__.Z),
-/* harmony export */   "gemini": () => (/* reexport safe */ _src_gemini_js__WEBPACK_IMPORTED_MODULE_60__.Z),
-/* harmony export */   "hitbtc": () => (/* reexport safe */ _src_hitbtc_js__WEBPACK_IMPORTED_MODULE_61__.Z),
-/* harmony export */   "hitbtc3": () => (/* reexport safe */ _src_hitbtc3_js__WEBPACK_IMPORTED_MODULE_62__.Z),
-/* harmony export */   "hollaex": () => (/* reexport safe */ _src_hollaex_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 */   "huobipro": () => (/* reexport safe */ _src_huobipro_js__WEBPACK_IMPORTED_MODULE_66__.Z),
-/* harmony export */   "idex": () => (/* reexport safe */ _src_idex_js__WEBPACK_IMPORTED_MODULE_67__.Z),
-/* harmony export */   "independentreserve": () => (/* reexport safe */ _src_independentreserve_js__WEBPACK_IMPORTED_MODULE_68__.Z),
-/* harmony export */   "indodax": () => (/* reexport safe */ _src_indodax_js__WEBPACK_IMPORTED_MODULE_69__.Z),
-/* harmony export */   "kraken": () => (/* reexport safe */ _src_kraken_js__WEBPACK_IMPORTED_MODULE_70__.Z),
-/* harmony export */   "krakenfutures": () => (/* reexport safe */ _src_krakenfutures_js__WEBPACK_IMPORTED_MODULE_71__.Z),
-/* harmony export */   "kucoin": () => (/* reexport safe */ _src_kucoin_js__WEBPACK_IMPORTED_MODULE_72__.Z),
-/* harmony export */   "kucoinfutures": () => (/* reexport safe */ _src_kucoinfutures_js__WEBPACK_IMPORTED_MODULE_73__.Z),
-/* harmony export */   "kuna": () => (/* reexport safe */ _src_kuna_js__WEBPACK_IMPORTED_MODULE_74__.Z),
-/* harmony export */   "latoken": () => (/* reexport safe */ _src_latoken_js__WEBPACK_IMPORTED_MODULE_75__.Z),
-/* harmony export */   "lbank": () => (/* reexport safe */ _src_lbank_js__WEBPACK_IMPORTED_MODULE_76__.Z),
-/* harmony export */   "lbank2": () => (/* reexport safe */ _src_lbank2_js__WEBPACK_IMPORTED_MODULE_77__.Z),
-/* harmony export */   "luno": () => (/* reexport safe */ _src_luno_js__WEBPACK_IMPORTED_MODULE_78__.Z),
-/* harmony export */   "lykke": () => (/* reexport safe */ _src_lykke_js__WEBPACK_IMPORTED_MODULE_79__.Z),
-/* harmony export */   "mercado": () => (/* reexport safe */ _src_mercado_js__WEBPACK_IMPORTED_MODULE_80__.Z),
-/* harmony export */   "mexc": () => (/* reexport safe */ _src_mexc_js__WEBPACK_IMPORTED_MODULE_81__.Z),
-/* harmony export */   "mexc3": () => (/* reexport safe */ _src_mexc3_js__WEBPACK_IMPORTED_MODULE_82__.Z),
-/* harmony export */   "ndax": () => (/* reexport safe */ _src_ndax_js__WEBPACK_IMPORTED_MODULE_83__.Z),
-/* harmony export */   "novadax": () => (/* reexport safe */ _src_novadax_js__WEBPACK_IMPORTED_MODULE_84__.Z),
-/* harmony export */   "oceanex": () => (/* reexport safe */ _src_oceanex_js__WEBPACK_IMPORTED_MODULE_85__.Z),
-/* harmony export */   "okcoin": () => (/* reexport safe */ _src_okcoin_js__WEBPACK_IMPORTED_MODULE_86__.Z),
-/* harmony export */   "okex": () => (/* reexport safe */ _src_okex_js__WEBPACK_IMPORTED_MODULE_87__.Z),
-/* harmony export */   "okex5": () => (/* reexport safe */ _src_okex5_js__WEBPACK_IMPORTED_MODULE_88__.Z),
-/* harmony export */   "okx": () => (/* reexport safe */ _src_okx_js__WEBPACK_IMPORTED_MODULE_89__.Z),
-/* harmony export */   "paymium": () => (/* reexport safe */ _src_paymium_js__WEBPACK_IMPORTED_MODULE_90__.Z),
-/* harmony export */   "phemex": () => (/* reexport safe */ _src_phemex_js__WEBPACK_IMPORTED_MODULE_91__.Z),
-/* harmony export */   "poloniex": () => (/* reexport safe */ _src_poloniex_js__WEBPACK_IMPORTED_MODULE_92__.Z),
-/* harmony export */   "poloniexfutures": () => (/* reexport safe */ _src_poloniexfutures_js__WEBPACK_IMPORTED_MODULE_93__.Z),
+/* harmony export */   "exmo": () => (/* reexport safe */ _src_exmo_js__WEBPACK_IMPORTED_MODULE_57__.Z),
+/* harmony export */   "fmfwio": () => (/* reexport safe */ _src_fmfwio_js__WEBPACK_IMPORTED_MODULE_58__.Z),
+/* harmony export */   "functions": () => (/* reexport module object */ _src_base_functions_js__WEBPACK_IMPORTED_MODULE_168__),
+/* harmony export */   "gate": () => (/* reexport safe */ _src_gate_js__WEBPACK_IMPORTED_MODULE_59__.Z),
+/* harmony export */   "gateio": () => (/* reexport safe */ _src_gateio_js__WEBPACK_IMPORTED_MODULE_60__.Z),
+/* harmony export */   "gemini": () => (/* reexport safe */ _src_gemini_js__WEBPACK_IMPORTED_MODULE_61__.Z),
+/* harmony export */   "hitbtc": () => (/* reexport safe */ _src_hitbtc_js__WEBPACK_IMPORTED_MODULE_62__.Z),
+/* harmony export */   "hitbtc3": () => (/* reexport safe */ _src_hitbtc3_js__WEBPACK_IMPORTED_MODULE_63__.Z),
+/* harmony export */   "hollaex": () => (/* reexport safe */ _src_hollaex_js__WEBPACK_IMPORTED_MODULE_64__.Z),
+/* harmony export */   "huobi": () => (/* reexport safe */ _src_huobi_js__WEBPACK_IMPORTED_MODULE_65__.Z),
+/* harmony export */   "huobijp": () => (/* reexport safe */ _src_huobijp_js__WEBPACK_IMPORTED_MODULE_66__.Z),
+/* harmony export */   "huobipro": () => (/* reexport safe */ _src_huobipro_js__WEBPACK_IMPORTED_MODULE_67__.Z),
+/* harmony export */   "idex": () => (/* reexport safe */ _src_idex_js__WEBPACK_IMPORTED_MODULE_68__.Z),
+/* harmony export */   "independentreserve": () => (/* reexport safe */ _src_independentreserve_js__WEBPACK_IMPORTED_MODULE_69__.Z),
+/* harmony export */   "indodax": () => (/* reexport safe */ _src_indodax_js__WEBPACK_IMPORTED_MODULE_70__.Z),
+/* harmony export */   "kraken": () => (/* reexport safe */ _src_kraken_js__WEBPACK_IMPORTED_MODULE_71__.Z),
+/* harmony export */   "krakenfutures": () => (/* reexport safe */ _src_krakenfutures_js__WEBPACK_IMPORTED_MODULE_72__.Z),
+/* harmony export */   "kucoin": () => (/* reexport safe */ _src_kucoin_js__WEBPACK_IMPORTED_MODULE_73__.Z),
+/* harmony export */   "kucoinfutures": () => (/* reexport safe */ _src_kucoinfutures_js__WEBPACK_IMPORTED_MODULE_74__.Z),
+/* harmony export */   "kuna": () => (/* reexport safe */ _src_kuna_js__WEBPACK_IMPORTED_MODULE_75__.Z),
+/* harmony export */   "latoken": () => (/* reexport safe */ _src_latoken_js__WEBPACK_IMPORTED_MODULE_76__.Z),
+/* harmony export */   "lbank": () => (/* reexport safe */ _src_lbank_js__WEBPACK_IMPORTED_MODULE_77__.Z),
+/* harmony export */   "lbank2": () => (/* reexport safe */ _src_lbank2_js__WEBPACK_IMPORTED_MODULE_78__.Z),
+/* harmony export */   "luno": () => (/* reexport safe */ _src_luno_js__WEBPACK_IMPORTED_MODULE_79__.Z),
+/* harmony export */   "lykke": () => (/* reexport safe */ _src_lykke_js__WEBPACK_IMPORTED_MODULE_80__.Z),
+/* harmony export */   "mercado": () => (/* reexport safe */ _src_mercado_js__WEBPACK_IMPORTED_MODULE_81__.Z),
+/* harmony export */   "mexc": () => (/* reexport safe */ _src_mexc_js__WEBPACK_IMPORTED_MODULE_82__.Z),
+/* harmony export */   "mexc3": () => (/* reexport safe */ _src_mexc3_js__WEBPACK_IMPORTED_MODULE_83__.Z),
+/* harmony export */   "ndax": () => (/* reexport safe */ _src_ndax_js__WEBPACK_IMPORTED_MODULE_84__.Z),
+/* harmony export */   "novadax": () => (/* reexport safe */ _src_novadax_js__WEBPACK_IMPORTED_MODULE_85__.Z),
+/* harmony export */   "oceanex": () => (/* reexport safe */ _src_oceanex_js__WEBPACK_IMPORTED_MODULE_86__.Z),
+/* harmony export */   "okcoin": () => (/* reexport safe */ _src_okcoin_js__WEBPACK_IMPORTED_MODULE_87__.Z),
+/* harmony export */   "okex": () => (/* reexport safe */ _src_okex_js__WEBPACK_IMPORTED_MODULE_88__.Z),
+/* harmony export */   "okex5": () => (/* reexport safe */ _src_okex5_js__WEBPACK_IMPORTED_MODULE_89__.Z),
+/* harmony export */   "okx": () => (/* reexport safe */ _src_okx_js__WEBPACK_IMPORTED_MODULE_90__.Z),
+/* harmony export */   "paymium": () => (/* reexport safe */ _src_paymium_js__WEBPACK_IMPORTED_MODULE_91__.Z),
+/* harmony export */   "phemex": () => (/* reexport safe */ _src_phemex_js__WEBPACK_IMPORTED_MODULE_92__.Z),
+/* harmony export */   "poloniex": () => (/* reexport safe */ _src_poloniex_js__WEBPACK_IMPORTED_MODULE_93__.Z),
+/* harmony export */   "poloniexfutures": () => (/* reexport safe */ _src_poloniexfutures_js__WEBPACK_IMPORTED_MODULE_94__.Z),
 /* harmony export */   "pro": () => (/* binding */ pro),
-/* harmony export */   "probit": () => (/* reexport safe */ _src_probit_js__WEBPACK_IMPORTED_MODULE_94__.Z),
-/* harmony export */   "tidex": () => (/* reexport safe */ _src_tidex_js__WEBPACK_IMPORTED_MODULE_95__.Z),
-/* harmony export */   "timex": () => (/* reexport safe */ _src_timex_js__WEBPACK_IMPORTED_MODULE_96__.Z),
-/* harmony export */   "tokocrypto": () => (/* reexport safe */ _src_tokocrypto_js__WEBPACK_IMPORTED_MODULE_97__.Z),
-/* harmony export */   "upbit": () => (/* reexport safe */ _src_upbit_js__WEBPACK_IMPORTED_MODULE_98__.Z),
+/* harmony export */   "probit": () => (/* reexport safe */ _src_probit_js__WEBPACK_IMPORTED_MODULE_95__.Z),
+/* harmony export */   "tidex": () => (/* reexport safe */ _src_tidex_js__WEBPACK_IMPORTED_MODULE_96__.Z),
+/* harmony export */   "timex": () => (/* reexport safe */ _src_timex_js__WEBPACK_IMPORTED_MODULE_97__.Z),
+/* harmony export */   "tokocrypto": () => (/* reexport safe */ _src_tokocrypto_js__WEBPACK_IMPORTED_MODULE_98__.Z),
+/* harmony export */   "upbit": () => (/* reexport safe */ _src_upbit_js__WEBPACK_IMPORTED_MODULE_99__.Z),
 /* harmony export */   "version": () => (/* binding */ version),
-/* harmony export */   "wavesexchange": () => (/* reexport safe */ _src_wavesexchange_js__WEBPACK_IMPORTED_MODULE_99__.Z),
-/* harmony export */   "wazirx": () => (/* reexport safe */ _src_wazirx_js__WEBPACK_IMPORTED_MODULE_100__.Z),
-/* harmony export */   "whitebit": () => (/* reexport safe */ _src_whitebit_js__WEBPACK_IMPORTED_MODULE_101__.Z),
-/* harmony export */   "woo": () => (/* reexport safe */ _src_woo_js__WEBPACK_IMPORTED_MODULE_102__.Z),
-/* harmony export */   "yobit": () => (/* reexport safe */ _src_yobit_js__WEBPACK_IMPORTED_MODULE_103__.Z),
-/* harmony export */   "zaif": () => (/* reexport safe */ _src_zaif_js__WEBPACK_IMPORTED_MODULE_104__.Z),
-/* harmony export */   "zonda": () => (/* reexport safe */ _src_zonda_js__WEBPACK_IMPORTED_MODULE_105__.Z)
+/* harmony export */   "wavesexchange": () => (/* reexport safe */ _src_wavesexchange_js__WEBPACK_IMPORTED_MODULE_100__.Z),
+/* harmony export */   "wazirx": () => (/* reexport safe */ _src_wazirx_js__WEBPACK_IMPORTED_MODULE_101__.Z),
+/* harmony export */   "whitebit": () => (/* reexport safe */ _src_whitebit_js__WEBPACK_IMPORTED_MODULE_102__.Z),
+/* harmony export */   "woo": () => (/* reexport safe */ _src_woo_js__WEBPACK_IMPORTED_MODULE_103__.Z),
+/* harmony export */   "yobit": () => (/* reexport safe */ _src_yobit_js__WEBPACK_IMPORTED_MODULE_104__.Z),
+/* harmony export */   "zaif": () => (/* reexport safe */ _src_zaif_js__WEBPACK_IMPORTED_MODULE_105__.Z),
+/* harmony export */   "zonda": () => (/* reexport safe */ _src_zonda_js__WEBPACK_IMPORTED_MODULE_106__.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_166__ = __webpack_require__(2194);
-/* harmony import */ var _src_base_functions_js__WEBPACK_IMPORTED_MODULE_167__ = __webpack_require__(7100);
-/* harmony import */ var _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__ = __webpack_require__(6689);
+/* harmony import */ var _src_base_Precise_js__WEBPACK_IMPORTED_MODULE_167__ = __webpack_require__(2194);
+/* harmony import */ var _src_base_functions_js__WEBPACK_IMPORTED_MODULE_168__ = __webpack_require__(7100);
+/* harmony import */ var _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__ = __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);
@@ -281645,125 +284163,126 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _src_coincheck_js__WEBPACK_IMPORTED_MODULE_44__ = __webpack_require__(2117);
 /* harmony import */ var _src_coinex_js__WEBPACK_IMPORTED_MODULE_45__ = __webpack_require__(332);
 /* harmony import */ var _src_coinfalcon_js__WEBPACK_IMPORTED_MODULE_46__ = __webpack_require__(5585);
-/* harmony import */ var _src_coinmate_js__WEBPACK_IMPORTED_MODULE_47__ = __webpack_require__(9816);
-/* harmony import */ var _src_coinone_js__WEBPACK_IMPORTED_MODULE_48__ = __webpack_require__(7811);
-/* harmony import */ var _src_coinsph_js__WEBPACK_IMPORTED_MODULE_49__ = __webpack_require__(5782);
-/* harmony import */ var _src_coinspot_js__WEBPACK_IMPORTED_MODULE_50__ = __webpack_require__(7794);
-/* harmony import */ var _src_cryptocom_js__WEBPACK_IMPORTED_MODULE_51__ = __webpack_require__(9129);
-/* harmony import */ var _src_currencycom_js__WEBPACK_IMPORTED_MODULE_52__ = __webpack_require__(3214);
-/* harmony import */ var _src_delta_js__WEBPACK_IMPORTED_MODULE_53__ = __webpack_require__(1753);
-/* harmony import */ var _src_deribit_js__WEBPACK_IMPORTED_MODULE_54__ = __webpack_require__(24);
-/* harmony import */ var _src_digifinex_js__WEBPACK_IMPORTED_MODULE_55__ = __webpack_require__(8846);
-/* harmony import */ var _src_exmo_js__WEBPACK_IMPORTED_MODULE_56__ = __webpack_require__(1729);
-/* harmony import */ var _src_fmfwio_js__WEBPACK_IMPORTED_MODULE_57__ = __webpack_require__(5788);
-/* harmony import */ var _src_gate_js__WEBPACK_IMPORTED_MODULE_58__ = __webpack_require__(7290);
-/* harmony import */ var _src_gateio_js__WEBPACK_IMPORTED_MODULE_59__ = __webpack_require__(7036);
-/* harmony import */ var _src_gemini_js__WEBPACK_IMPORTED_MODULE_60__ = __webpack_require__(6743);
-/* harmony import */ var _src_hitbtc_js__WEBPACK_IMPORTED_MODULE_61__ = __webpack_require__(4714);
-/* harmony import */ var _src_hitbtc3_js__WEBPACK_IMPORTED_MODULE_62__ = __webpack_require__(4815);
-/* harmony import */ var _src_hollaex_js__WEBPACK_IMPORTED_MODULE_63__ = __webpack_require__(8422);
-/* 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_huobipro_js__WEBPACK_IMPORTED_MODULE_66__ = __webpack_require__(5547);
-/* harmony import */ var _src_idex_js__WEBPACK_IMPORTED_MODULE_67__ = __webpack_require__(8232);
-/* harmony import */ var _src_independentreserve_js__WEBPACK_IMPORTED_MODULE_68__ = __webpack_require__(9570);
-/* harmony import */ var _src_indodax_js__WEBPACK_IMPORTED_MODULE_69__ = __webpack_require__(1605);
-/* harmony import */ var _src_kraken_js__WEBPACK_IMPORTED_MODULE_70__ = __webpack_require__(9922);
-/* harmony import */ var _src_krakenfutures_js__WEBPACK_IMPORTED_MODULE_71__ = __webpack_require__(4470);
-/* harmony import */ var _src_kucoin_js__WEBPACK_IMPORTED_MODULE_72__ = __webpack_require__(3583);
-/* harmony import */ var _src_kucoinfutures_js__WEBPACK_IMPORTED_MODULE_73__ = __webpack_require__(1924);
-/* harmony import */ var _src_kuna_js__WEBPACK_IMPORTED_MODULE_74__ = __webpack_require__(7732);
-/* harmony import */ var _src_latoken_js__WEBPACK_IMPORTED_MODULE_75__ = __webpack_require__(2545);
-/* harmony import */ var _src_lbank_js__WEBPACK_IMPORTED_MODULE_76__ = __webpack_require__(3944);
-/* harmony import */ var _src_lbank2_js__WEBPACK_IMPORTED_MODULE_77__ = __webpack_require__(8601);
-/* harmony import */ var _src_luno_js__WEBPACK_IMPORTED_MODULE_78__ = __webpack_require__(1758);
-/* harmony import */ var _src_lykke_js__WEBPACK_IMPORTED_MODULE_79__ = __webpack_require__(3803);
-/* harmony import */ var _src_mercado_js__WEBPACK_IMPORTED_MODULE_80__ = __webpack_require__(9013);
-/* harmony import */ var _src_mexc_js__WEBPACK_IMPORTED_MODULE_81__ = __webpack_require__(6641);
-/* harmony import */ var _src_mexc3_js__WEBPACK_IMPORTED_MODULE_82__ = __webpack_require__(2305);
-/* harmony import */ var _src_ndax_js__WEBPACK_IMPORTED_MODULE_83__ = __webpack_require__(4531);
-/* harmony import */ var _src_novadax_js__WEBPACK_IMPORTED_MODULE_84__ = __webpack_require__(2449);
-/* harmony import */ var _src_oceanex_js__WEBPACK_IMPORTED_MODULE_85__ = __webpack_require__(6749);
-/* harmony import */ var _src_okcoin_js__WEBPACK_IMPORTED_MODULE_86__ = __webpack_require__(3007);
-/* harmony import */ var _src_okex_js__WEBPACK_IMPORTED_MODULE_87__ = __webpack_require__(5322);
-/* harmony import */ var _src_okex5_js__WEBPACK_IMPORTED_MODULE_88__ = __webpack_require__(7826);
-/* harmony import */ var _src_okx_js__WEBPACK_IMPORTED_MODULE_89__ = __webpack_require__(4042);
-/* harmony import */ var _src_paymium_js__WEBPACK_IMPORTED_MODULE_90__ = __webpack_require__(7082);
-/* harmony import */ var _src_phemex_js__WEBPACK_IMPORTED_MODULE_91__ = __webpack_require__(79);
-/* harmony import */ var _src_poloniex_js__WEBPACK_IMPORTED_MODULE_92__ = __webpack_require__(8891);
-/* harmony import */ var _src_poloniexfutures_js__WEBPACK_IMPORTED_MODULE_93__ = __webpack_require__(6877);
-/* harmony import */ var _src_probit_js__WEBPACK_IMPORTED_MODULE_94__ = __webpack_require__(3657);
-/* harmony import */ var _src_tidex_js__WEBPACK_IMPORTED_MODULE_95__ = __webpack_require__(4224);
-/* harmony import */ var _src_timex_js__WEBPACK_IMPORTED_MODULE_96__ = __webpack_require__(1067);
-/* harmony import */ var _src_tokocrypto_js__WEBPACK_IMPORTED_MODULE_97__ = __webpack_require__(5261);
-/* harmony import */ var _src_upbit_js__WEBPACK_IMPORTED_MODULE_98__ = __webpack_require__(7584);
-/* harmony import */ var _src_wavesexchange_js__WEBPACK_IMPORTED_MODULE_99__ = __webpack_require__(3853);
-/* harmony import */ var _src_wazirx_js__WEBPACK_IMPORTED_MODULE_100__ = __webpack_require__(6536);
-/* harmony import */ var _src_whitebit_js__WEBPACK_IMPORTED_MODULE_101__ = __webpack_require__(5467);
-/* harmony import */ var _src_woo_js__WEBPACK_IMPORTED_MODULE_102__ = __webpack_require__(517);
-/* harmony import */ var _src_yobit_js__WEBPACK_IMPORTED_MODULE_103__ = __webpack_require__(3850);
-/* harmony import */ var _src_zaif_js__WEBPACK_IMPORTED_MODULE_104__ = __webpack_require__(5934);
-/* harmony import */ var _src_zonda_js__WEBPACK_IMPORTED_MODULE_105__ = __webpack_require__(5140);
-/* harmony import */ var _src_pro_alpaca_js__WEBPACK_IMPORTED_MODULE_106__ = __webpack_require__(2467);
-/* harmony import */ var _src_pro_ascendex_js__WEBPACK_IMPORTED_MODULE_107__ = __webpack_require__(2383);
-/* harmony import */ var _src_pro_bequant_js__WEBPACK_IMPORTED_MODULE_108__ = __webpack_require__(8848);
-/* harmony import */ var _src_pro_binance_js__WEBPACK_IMPORTED_MODULE_109__ = __webpack_require__(8764);
-/* harmony import */ var _src_pro_binancecoinm_js__WEBPACK_IMPORTED_MODULE_110__ = __webpack_require__(5078);
-/* harmony import */ var _src_pro_binanceus_js__WEBPACK_IMPORTED_MODULE_111__ = __webpack_require__(1326);
-/* harmony import */ var _src_pro_binanceusdm_js__WEBPACK_IMPORTED_MODULE_112__ = __webpack_require__(1230);
-/* harmony import */ var _src_pro_bingx_js__WEBPACK_IMPORTED_MODULE_113__ = __webpack_require__(6955);
-/* harmony import */ var _src_pro_bitcoincom_js__WEBPACK_IMPORTED_MODULE_114__ = __webpack_require__(453);
-/* harmony import */ var _src_pro_bitfinex_js__WEBPACK_IMPORTED_MODULE_115__ = __webpack_require__(9772);
-/* harmony import */ var _src_pro_bitfinex2_js__WEBPACK_IMPORTED_MODULE_116__ = __webpack_require__(588);
-/* harmony import */ var _src_pro_bitget_js__WEBPACK_IMPORTED_MODULE_117__ = __webpack_require__(1885);
-/* harmony import */ var _src_pro_bitmart_js__WEBPACK_IMPORTED_MODULE_118__ = __webpack_require__(7504);
-/* harmony import */ var _src_pro_bitmex_js__WEBPACK_IMPORTED_MODULE_119__ = __webpack_require__(2302);
-/* harmony import */ var _src_pro_bitopro_js__WEBPACK_IMPORTED_MODULE_120__ = __webpack_require__(2191);
-/* harmony import */ var _src_pro_bitpanda_js__WEBPACK_IMPORTED_MODULE_121__ = __webpack_require__(1297);
-/* harmony import */ var _src_pro_bitrue_js__WEBPACK_IMPORTED_MODULE_122__ = __webpack_require__(3005);
-/* harmony import */ var _src_pro_bitstamp_js__WEBPACK_IMPORTED_MODULE_123__ = __webpack_require__(3623);
-/* harmony import */ var _src_pro_bittrex_js__WEBPACK_IMPORTED_MODULE_124__ = __webpack_require__(2883);
-/* harmony import */ var _src_pro_bitvavo_js__WEBPACK_IMPORTED_MODULE_125__ = __webpack_require__(6977);
-/* harmony import */ var _src_pro_blockchaincom_js__WEBPACK_IMPORTED_MODULE_126__ = __webpack_require__(2519);
-/* harmony import */ var _src_pro_bybit_js__WEBPACK_IMPORTED_MODULE_127__ = __webpack_require__(5030);
-/* harmony import */ var _src_pro_cex_js__WEBPACK_IMPORTED_MODULE_128__ = __webpack_require__(5272);
-/* harmony import */ var _src_pro_coinbase_js__WEBPACK_IMPORTED_MODULE_129__ = __webpack_require__(3414);
-/* harmony import */ var _src_pro_coinbaseprime_js__WEBPACK_IMPORTED_MODULE_130__ = __webpack_require__(3848);
-/* harmony import */ var _src_pro_coinbasepro_js__WEBPACK_IMPORTED_MODULE_131__ = __webpack_require__(8368);
-/* harmony import */ var _src_pro_coinex_js__WEBPACK_IMPORTED_MODULE_132__ = __webpack_require__(204);
-/* harmony import */ var _src_pro_cryptocom_js__WEBPACK_IMPORTED_MODULE_133__ = __webpack_require__(6820);
-/* harmony import */ var _src_pro_currencycom_js__WEBPACK_IMPORTED_MODULE_134__ = __webpack_require__(2952);
-/* harmony import */ var _src_pro_deribit_js__WEBPACK_IMPORTED_MODULE_135__ = __webpack_require__(1788);
-/* harmony import */ var _src_pro_exmo_js__WEBPACK_IMPORTED_MODULE_136__ = __webpack_require__(9004);
-/* harmony import */ var _src_pro_gate_js__WEBPACK_IMPORTED_MODULE_137__ = __webpack_require__(8335);
-/* harmony import */ var _src_pro_gateio_js__WEBPACK_IMPORTED_MODULE_138__ = __webpack_require__(1465);
-/* harmony import */ var _src_pro_gemini_js__WEBPACK_IMPORTED_MODULE_139__ = __webpack_require__(9488);
-/* harmony import */ var _src_pro_hitbtc_js__WEBPACK_IMPORTED_MODULE_140__ = __webpack_require__(5189);
-/* harmony import */ var _src_pro_hollaex_js__WEBPACK_IMPORTED_MODULE_141__ = __webpack_require__(8559);
-/* harmony import */ var _src_pro_huobi_js__WEBPACK_IMPORTED_MODULE_142__ = __webpack_require__(8384);
-/* harmony import */ var _src_pro_huobijp_js__WEBPACK_IMPORTED_MODULE_143__ = __webpack_require__(9021);
-/* harmony import */ var _src_pro_huobipro_js__WEBPACK_IMPORTED_MODULE_144__ = __webpack_require__(4625);
-/* harmony import */ var _src_pro_idex_js__WEBPACK_IMPORTED_MODULE_145__ = __webpack_require__(3484);
-/* harmony import */ var _src_pro_independentreserve_js__WEBPACK_IMPORTED_MODULE_146__ = __webpack_require__(1311);
-/* harmony import */ var _src_pro_kraken_js__WEBPACK_IMPORTED_MODULE_147__ = __webpack_require__(736);
-/* harmony import */ var _src_pro_krakenfutures_js__WEBPACK_IMPORTED_MODULE_148__ = __webpack_require__(449);
-/* harmony import */ var _src_pro_kucoin_js__WEBPACK_IMPORTED_MODULE_149__ = __webpack_require__(2387);
-/* harmony import */ var _src_pro_kucoinfutures_js__WEBPACK_IMPORTED_MODULE_150__ = __webpack_require__(7181);
-/* harmony import */ var _src_pro_luno_js__WEBPACK_IMPORTED_MODULE_151__ = __webpack_require__(627);
-/* harmony import */ var _src_pro_mexc_js__WEBPACK_IMPORTED_MODULE_152__ = __webpack_require__(6484);
-/* harmony import */ var _src_pro_mexc3_js__WEBPACK_IMPORTED_MODULE_153__ = __webpack_require__(5351);
-/* harmony import */ var _src_pro_ndax_js__WEBPACK_IMPORTED_MODULE_154__ = __webpack_require__(8080);
-/* harmony import */ var _src_pro_okcoin_js__WEBPACK_IMPORTED_MODULE_155__ = __webpack_require__(7105);
-/* harmony import */ var _src_pro_okex_js__WEBPACK_IMPORTED_MODULE_156__ = __webpack_require__(1530);
-/* harmony import */ var _src_pro_okx_js__WEBPACK_IMPORTED_MODULE_157__ = __webpack_require__(2214);
-/* harmony import */ var _src_pro_phemex_js__WEBPACK_IMPORTED_MODULE_158__ = __webpack_require__(4360);
-/* harmony import */ var _src_pro_poloniex_js__WEBPACK_IMPORTED_MODULE_159__ = __webpack_require__(7924);
-/* harmony import */ var _src_pro_poloniexfutures_js__WEBPACK_IMPORTED_MODULE_160__ = __webpack_require__(3541);
-/* harmony import */ var _src_pro_probit_js__WEBPACK_IMPORTED_MODULE_161__ = __webpack_require__(9782);
-/* harmony import */ var _src_pro_upbit_js__WEBPACK_IMPORTED_MODULE_162__ = __webpack_require__(7614);
-/* harmony import */ var _src_pro_wazirx_js__WEBPACK_IMPORTED_MODULE_163__ = __webpack_require__(4828);
-/* harmony import */ var _src_pro_whitebit_js__WEBPACK_IMPORTED_MODULE_164__ = __webpack_require__(5630);
-/* harmony import */ var _src_pro_woo_js__WEBPACK_IMPORTED_MODULE_165__ = __webpack_require__(3910);
+/* harmony import */ var _src_coinlist_js__WEBPACK_IMPORTED_MODULE_47__ = __webpack_require__(3623);
+/* harmony import */ var _src_coinmate_js__WEBPACK_IMPORTED_MODULE_48__ = __webpack_require__(9816);
+/* harmony import */ var _src_coinone_js__WEBPACK_IMPORTED_MODULE_49__ = __webpack_require__(7811);
+/* harmony import */ var _src_coinsph_js__WEBPACK_IMPORTED_MODULE_50__ = __webpack_require__(5782);
+/* harmony import */ var _src_coinspot_js__WEBPACK_IMPORTED_MODULE_51__ = __webpack_require__(7794);
+/* harmony import */ var _src_cryptocom_js__WEBPACK_IMPORTED_MODULE_52__ = __webpack_require__(9129);
+/* harmony import */ var _src_currencycom_js__WEBPACK_IMPORTED_MODULE_53__ = __webpack_require__(3214);
+/* harmony import */ var _src_delta_js__WEBPACK_IMPORTED_MODULE_54__ = __webpack_require__(1753);
+/* harmony import */ var _src_deribit_js__WEBPACK_IMPORTED_MODULE_55__ = __webpack_require__(24);
+/* harmony import */ var _src_digifinex_js__WEBPACK_IMPORTED_MODULE_56__ = __webpack_require__(8846);
+/* harmony import */ var _src_exmo_js__WEBPACK_IMPORTED_MODULE_57__ = __webpack_require__(1729);
+/* harmony import */ var _src_fmfwio_js__WEBPACK_IMPORTED_MODULE_58__ = __webpack_require__(5788);
+/* harmony import */ var _src_gate_js__WEBPACK_IMPORTED_MODULE_59__ = __webpack_require__(7290);
+/* harmony import */ var _src_gateio_js__WEBPACK_IMPORTED_MODULE_60__ = __webpack_require__(7036);
+/* harmony import */ var _src_gemini_js__WEBPACK_IMPORTED_MODULE_61__ = __webpack_require__(6743);
+/* harmony import */ var _src_hitbtc_js__WEBPACK_IMPORTED_MODULE_62__ = __webpack_require__(4714);
+/* harmony import */ var _src_hitbtc3_js__WEBPACK_IMPORTED_MODULE_63__ = __webpack_require__(4815);
+/* harmony import */ var _src_hollaex_js__WEBPACK_IMPORTED_MODULE_64__ = __webpack_require__(8422);
+/* harmony import */ var _src_huobi_js__WEBPACK_IMPORTED_MODULE_65__ = __webpack_require__(8146);
+/* harmony import */ var _src_huobijp_js__WEBPACK_IMPORTED_MODULE_66__ = __webpack_require__(7034);
+/* harmony import */ var _src_huobipro_js__WEBPACK_IMPORTED_MODULE_67__ = __webpack_require__(5547);
+/* harmony import */ var _src_idex_js__WEBPACK_IMPORTED_MODULE_68__ = __webpack_require__(8232);
+/* harmony import */ var _src_independentreserve_js__WEBPACK_IMPORTED_MODULE_69__ = __webpack_require__(9570);
+/* harmony import */ var _src_indodax_js__WEBPACK_IMPORTED_MODULE_70__ = __webpack_require__(1605);
+/* harmony import */ var _src_kraken_js__WEBPACK_IMPORTED_MODULE_71__ = __webpack_require__(9922);
+/* harmony import */ var _src_krakenfutures_js__WEBPACK_IMPORTED_MODULE_72__ = __webpack_require__(4470);
+/* harmony import */ var _src_kucoin_js__WEBPACK_IMPORTED_MODULE_73__ = __webpack_require__(3583);
+/* harmony import */ var _src_kucoinfutures_js__WEBPACK_IMPORTED_MODULE_74__ = __webpack_require__(1924);
+/* harmony import */ var _src_kuna_js__WEBPACK_IMPORTED_MODULE_75__ = __webpack_require__(7732);
+/* harmony import */ var _src_latoken_js__WEBPACK_IMPORTED_MODULE_76__ = __webpack_require__(2545);
+/* harmony import */ var _src_lbank_js__WEBPACK_IMPORTED_MODULE_77__ = __webpack_require__(3944);
+/* harmony import */ var _src_lbank2_js__WEBPACK_IMPORTED_MODULE_78__ = __webpack_require__(8601);
+/* harmony import */ var _src_luno_js__WEBPACK_IMPORTED_MODULE_79__ = __webpack_require__(1758);
+/* harmony import */ var _src_lykke_js__WEBPACK_IMPORTED_MODULE_80__ = __webpack_require__(3803);
+/* harmony import */ var _src_mercado_js__WEBPACK_IMPORTED_MODULE_81__ = __webpack_require__(9013);
+/* harmony import */ var _src_mexc_js__WEBPACK_IMPORTED_MODULE_82__ = __webpack_require__(6641);
+/* harmony import */ var _src_mexc3_js__WEBPACK_IMPORTED_MODULE_83__ = __webpack_require__(2305);
+/* harmony import */ var _src_ndax_js__WEBPACK_IMPORTED_MODULE_84__ = __webpack_require__(4531);
+/* harmony import */ var _src_novadax_js__WEBPACK_IMPORTED_MODULE_85__ = __webpack_require__(2449);
+/* harmony import */ var _src_oceanex_js__WEBPACK_IMPORTED_MODULE_86__ = __webpack_require__(6749);
+/* harmony import */ var _src_okcoin_js__WEBPACK_IMPORTED_MODULE_87__ = __webpack_require__(3007);
+/* harmony import */ var _src_okex_js__WEBPACK_IMPORTED_MODULE_88__ = __webpack_require__(5322);
+/* harmony import */ var _src_okex5_js__WEBPACK_IMPORTED_MODULE_89__ = __webpack_require__(7826);
+/* harmony import */ var _src_okx_js__WEBPACK_IMPORTED_MODULE_90__ = __webpack_require__(4042);
+/* harmony import */ var _src_paymium_js__WEBPACK_IMPORTED_MODULE_91__ = __webpack_require__(7082);
+/* harmony import */ var _src_phemex_js__WEBPACK_IMPORTED_MODULE_92__ = __webpack_require__(79);
+/* harmony import */ var _src_poloniex_js__WEBPACK_IMPORTED_MODULE_93__ = __webpack_require__(8891);
+/* harmony import */ var _src_poloniexfutures_js__WEBPACK_IMPORTED_MODULE_94__ = __webpack_require__(6877);
+/* harmony import */ var _src_probit_js__WEBPACK_IMPORTED_MODULE_95__ = __webpack_require__(3657);
+/* harmony import */ var _src_tidex_js__WEBPACK_IMPORTED_MODULE_96__ = __webpack_require__(4224);
+/* harmony import */ var _src_timex_js__WEBPACK_IMPORTED_MODULE_97__ = __webpack_require__(1067);
+/* harmony import */ var _src_tokocrypto_js__WEBPACK_IMPORTED_MODULE_98__ = __webpack_require__(5261);
+/* harmony import */ var _src_upbit_js__WEBPACK_IMPORTED_MODULE_99__ = __webpack_require__(7584);
+/* harmony import */ var _src_wavesexchange_js__WEBPACK_IMPORTED_MODULE_100__ = __webpack_require__(3853);
+/* harmony import */ var _src_wazirx_js__WEBPACK_IMPORTED_MODULE_101__ = __webpack_require__(6536);
+/* harmony import */ var _src_whitebit_js__WEBPACK_IMPORTED_MODULE_102__ = __webpack_require__(5467);
+/* harmony import */ var _src_woo_js__WEBPACK_IMPORTED_MODULE_103__ = __webpack_require__(517);
+/* harmony import */ var _src_yobit_js__WEBPACK_IMPORTED_MODULE_104__ = __webpack_require__(3850);
+/* harmony import */ var _src_zaif_js__WEBPACK_IMPORTED_MODULE_105__ = __webpack_require__(5934);
+/* harmony import */ var _src_zonda_js__WEBPACK_IMPORTED_MODULE_106__ = __webpack_require__(5140);
+/* harmony import */ var _src_pro_alpaca_js__WEBPACK_IMPORTED_MODULE_107__ = __webpack_require__(2467);
+/* harmony import */ var _src_pro_ascendex_js__WEBPACK_IMPORTED_MODULE_108__ = __webpack_require__(2383);
+/* harmony import */ var _src_pro_bequant_js__WEBPACK_IMPORTED_MODULE_109__ = __webpack_require__(8848);
+/* harmony import */ var _src_pro_binance_js__WEBPACK_IMPORTED_MODULE_110__ = __webpack_require__(8764);
+/* harmony import */ var _src_pro_binancecoinm_js__WEBPACK_IMPORTED_MODULE_111__ = __webpack_require__(5078);
+/* harmony import */ var _src_pro_binanceus_js__WEBPACK_IMPORTED_MODULE_112__ = __webpack_require__(1326);
+/* harmony import */ var _src_pro_binanceusdm_js__WEBPACK_IMPORTED_MODULE_113__ = __webpack_require__(1230);
+/* harmony import */ var _src_pro_bingx_js__WEBPACK_IMPORTED_MODULE_114__ = __webpack_require__(6955);
+/* harmony import */ var _src_pro_bitcoincom_js__WEBPACK_IMPORTED_MODULE_115__ = __webpack_require__(453);
+/* harmony import */ var _src_pro_bitfinex_js__WEBPACK_IMPORTED_MODULE_116__ = __webpack_require__(9772);
+/* harmony import */ var _src_pro_bitfinex2_js__WEBPACK_IMPORTED_MODULE_117__ = __webpack_require__(588);
+/* harmony import */ var _src_pro_bitget_js__WEBPACK_IMPORTED_MODULE_118__ = __webpack_require__(1885);
+/* harmony import */ var _src_pro_bitmart_js__WEBPACK_IMPORTED_MODULE_119__ = __webpack_require__(7504);
+/* harmony import */ var _src_pro_bitmex_js__WEBPACK_IMPORTED_MODULE_120__ = __webpack_require__(2302);
+/* harmony import */ var _src_pro_bitopro_js__WEBPACK_IMPORTED_MODULE_121__ = __webpack_require__(2191);
+/* harmony import */ var _src_pro_bitpanda_js__WEBPACK_IMPORTED_MODULE_122__ = __webpack_require__(1297);
+/* harmony import */ var _src_pro_bitrue_js__WEBPACK_IMPORTED_MODULE_123__ = __webpack_require__(3005);
+/* harmony import */ var _src_pro_bitstamp_js__WEBPACK_IMPORTED_MODULE_124__ = __webpack_require__(2317);
+/* harmony import */ var _src_pro_bittrex_js__WEBPACK_IMPORTED_MODULE_125__ = __webpack_require__(2883);
+/* harmony import */ var _src_pro_bitvavo_js__WEBPACK_IMPORTED_MODULE_126__ = __webpack_require__(6977);
+/* harmony import */ var _src_pro_blockchaincom_js__WEBPACK_IMPORTED_MODULE_127__ = __webpack_require__(2519);
+/* harmony import */ var _src_pro_bybit_js__WEBPACK_IMPORTED_MODULE_128__ = __webpack_require__(5030);
+/* harmony import */ var _src_pro_cex_js__WEBPACK_IMPORTED_MODULE_129__ = __webpack_require__(5272);
+/* harmony import */ var _src_pro_coinbase_js__WEBPACK_IMPORTED_MODULE_130__ = __webpack_require__(3414);
+/* harmony import */ var _src_pro_coinbaseprime_js__WEBPACK_IMPORTED_MODULE_131__ = __webpack_require__(3848);
+/* harmony import */ var _src_pro_coinbasepro_js__WEBPACK_IMPORTED_MODULE_132__ = __webpack_require__(8368);
+/* harmony import */ var _src_pro_coinex_js__WEBPACK_IMPORTED_MODULE_133__ = __webpack_require__(204);
+/* harmony import */ var _src_pro_cryptocom_js__WEBPACK_IMPORTED_MODULE_134__ = __webpack_require__(6820);
+/* harmony import */ var _src_pro_currencycom_js__WEBPACK_IMPORTED_MODULE_135__ = __webpack_require__(2952);
+/* harmony import */ var _src_pro_deribit_js__WEBPACK_IMPORTED_MODULE_136__ = __webpack_require__(1788);
+/* harmony import */ var _src_pro_exmo_js__WEBPACK_IMPORTED_MODULE_137__ = __webpack_require__(9004);
+/* harmony import */ var _src_pro_gate_js__WEBPACK_IMPORTED_MODULE_138__ = __webpack_require__(8335);
+/* harmony import */ var _src_pro_gateio_js__WEBPACK_IMPORTED_MODULE_139__ = __webpack_require__(1465);
+/* harmony import */ var _src_pro_gemini_js__WEBPACK_IMPORTED_MODULE_140__ = __webpack_require__(9488);
+/* harmony import */ var _src_pro_hitbtc_js__WEBPACK_IMPORTED_MODULE_141__ = __webpack_require__(5189);
+/* harmony import */ var _src_pro_hollaex_js__WEBPACK_IMPORTED_MODULE_142__ = __webpack_require__(8559);
+/* harmony import */ var _src_pro_huobi_js__WEBPACK_IMPORTED_MODULE_143__ = __webpack_require__(8384);
+/* harmony import */ var _src_pro_huobijp_js__WEBPACK_IMPORTED_MODULE_144__ = __webpack_require__(9021);
+/* harmony import */ var _src_pro_huobipro_js__WEBPACK_IMPORTED_MODULE_145__ = __webpack_require__(4625);
+/* harmony import */ var _src_pro_idex_js__WEBPACK_IMPORTED_MODULE_146__ = __webpack_require__(3484);
+/* harmony import */ var _src_pro_independentreserve_js__WEBPACK_IMPORTED_MODULE_147__ = __webpack_require__(1311);
+/* harmony import */ var _src_pro_kraken_js__WEBPACK_IMPORTED_MODULE_148__ = __webpack_require__(736);
+/* harmony import */ var _src_pro_krakenfutures_js__WEBPACK_IMPORTED_MODULE_149__ = __webpack_require__(449);
+/* harmony import */ var _src_pro_kucoin_js__WEBPACK_IMPORTED_MODULE_150__ = __webpack_require__(2387);
+/* harmony import */ var _src_pro_kucoinfutures_js__WEBPACK_IMPORTED_MODULE_151__ = __webpack_require__(7181);
+/* harmony import */ var _src_pro_luno_js__WEBPACK_IMPORTED_MODULE_152__ = __webpack_require__(627);
+/* harmony import */ var _src_pro_mexc_js__WEBPACK_IMPORTED_MODULE_153__ = __webpack_require__(6484);
+/* harmony import */ var _src_pro_mexc3_js__WEBPACK_IMPORTED_MODULE_154__ = __webpack_require__(5351);
+/* harmony import */ var _src_pro_ndax_js__WEBPACK_IMPORTED_MODULE_155__ = __webpack_require__(8080);
+/* harmony import */ var _src_pro_okcoin_js__WEBPACK_IMPORTED_MODULE_156__ = __webpack_require__(7105);
+/* harmony import */ var _src_pro_okex_js__WEBPACK_IMPORTED_MODULE_157__ = __webpack_require__(1530);
+/* harmony import */ var _src_pro_okx_js__WEBPACK_IMPORTED_MODULE_158__ = __webpack_require__(2214);
+/* harmony import */ var _src_pro_phemex_js__WEBPACK_IMPORTED_MODULE_159__ = __webpack_require__(4360);
+/* harmony import */ var _src_pro_poloniex_js__WEBPACK_IMPORTED_MODULE_160__ = __webpack_require__(7924);
+/* harmony import */ var _src_pro_poloniexfutures_js__WEBPACK_IMPORTED_MODULE_161__ = __webpack_require__(3541);
+/* harmony import */ var _src_pro_probit_js__WEBPACK_IMPORTED_MODULE_162__ = __webpack_require__(9782);
+/* harmony import */ var _src_pro_upbit_js__WEBPACK_IMPORTED_MODULE_163__ = __webpack_require__(7614);
+/* harmony import */ var _src_pro_wazirx_js__WEBPACK_IMPORTED_MODULE_164__ = __webpack_require__(4828);
+/* harmony import */ var _src_pro_whitebit_js__WEBPACK_IMPORTED_MODULE_165__ = __webpack_require__(5630);
+/* harmony import */ var _src_pro_woo_js__WEBPACK_IMPORTED_MODULE_166__ = __webpack_require__(3910);
 /*
 
 MIT License
@@ -281798,7 +284317,7 @@ SOFTWARE.
 
 //-----------------------------------------------------------------------------
 // this is updated by vss.js when building
-const version = '4.1.41';
+const version = '4.1.43';
 _src_base_Exchange_js__WEBPACK_IMPORTED_MODULE_0__/* .Exchange.ccxtVersion */ .e.ccxtVersion = version;
 //-----------------------------------------------------------------------------
 
@@ -281904,6 +284423,7 @@ _src_base_Exchange_js__WEBPACK_IMPORTED_MODULE_0__/* .Exchange.ccxtVersion */ .e
 
 
 
+
 
 
 // pro exchanges
@@ -282014,127 +284534,128 @@ const exchanges = {
     'coincheck': _src_coincheck_js__WEBPACK_IMPORTED_MODULE_44__/* ["default"] */ .Z,
     'coinex': _src_coinex_js__WEBPACK_IMPORTED_MODULE_45__/* ["default"] */ .Z,
     'coinfalcon': _src_coinfalcon_js__WEBPACK_IMPORTED_MODULE_46__/* ["default"] */ .Z,
-    'coinmate': _src_coinmate_js__WEBPACK_IMPORTED_MODULE_47__/* ["default"] */ .Z,
-    'coinone': _src_coinone_js__WEBPACK_IMPORTED_MODULE_48__/* ["default"] */ .Z,
-    'coinsph': _src_coinsph_js__WEBPACK_IMPORTED_MODULE_49__/* ["default"] */ .Z,
-    'coinspot': _src_coinspot_js__WEBPACK_IMPORTED_MODULE_50__/* ["default"] */ .Z,
-    'cryptocom': _src_cryptocom_js__WEBPACK_IMPORTED_MODULE_51__/* ["default"] */ .Z,
-    'currencycom': _src_currencycom_js__WEBPACK_IMPORTED_MODULE_52__/* ["default"] */ .Z,
-    'delta': _src_delta_js__WEBPACK_IMPORTED_MODULE_53__/* ["default"] */ .Z,
-    'deribit': _src_deribit_js__WEBPACK_IMPORTED_MODULE_54__/* ["default"] */ .Z,
-    'digifinex': _src_digifinex_js__WEBPACK_IMPORTED_MODULE_55__/* ["default"] */ .Z,
-    'exmo': _src_exmo_js__WEBPACK_IMPORTED_MODULE_56__/* ["default"] */ .Z,
-    'fmfwio': _src_fmfwio_js__WEBPACK_IMPORTED_MODULE_57__/* ["default"] */ .Z,
-    'gate': _src_gate_js__WEBPACK_IMPORTED_MODULE_58__/* ["default"] */ .Z,
-    'gateio': _src_gateio_js__WEBPACK_IMPORTED_MODULE_59__/* ["default"] */ .Z,
-    'gemini': _src_gemini_js__WEBPACK_IMPORTED_MODULE_60__/* ["default"] */ .Z,
-    'hitbtc': _src_hitbtc_js__WEBPACK_IMPORTED_MODULE_61__/* ["default"] */ .Z,
-    'hitbtc3': _src_hitbtc3_js__WEBPACK_IMPORTED_MODULE_62__/* ["default"] */ .Z,
-    'hollaex': _src_hollaex_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,
-    'huobipro': _src_huobipro_js__WEBPACK_IMPORTED_MODULE_66__/* ["default"] */ .Z,
-    'idex': _src_idex_js__WEBPACK_IMPORTED_MODULE_67__/* ["default"] */ .Z,
-    'independentreserve': _src_independentreserve_js__WEBPACK_IMPORTED_MODULE_68__/* ["default"] */ .Z,
-    'indodax': _src_indodax_js__WEBPACK_IMPORTED_MODULE_69__/* ["default"] */ .Z,
-    'kraken': _src_kraken_js__WEBPACK_IMPORTED_MODULE_70__/* ["default"] */ .Z,
-    'krakenfutures': _src_krakenfutures_js__WEBPACK_IMPORTED_MODULE_71__/* ["default"] */ .Z,
-    'kucoin': _src_kucoin_js__WEBPACK_IMPORTED_MODULE_72__/* ["default"] */ .Z,
-    'kucoinfutures': _src_kucoinfutures_js__WEBPACK_IMPORTED_MODULE_73__/* ["default"] */ .Z,
-    'kuna': _src_kuna_js__WEBPACK_IMPORTED_MODULE_74__/* ["default"] */ .Z,
-    'latoken': _src_latoken_js__WEBPACK_IMPORTED_MODULE_75__/* ["default"] */ .Z,
-    'lbank': _src_lbank_js__WEBPACK_IMPORTED_MODULE_76__/* ["default"] */ .Z,
-    'lbank2': _src_lbank2_js__WEBPACK_IMPORTED_MODULE_77__/* ["default"] */ .Z,
-    'luno': _src_luno_js__WEBPACK_IMPORTED_MODULE_78__/* ["default"] */ .Z,
-    'lykke': _src_lykke_js__WEBPACK_IMPORTED_MODULE_79__/* ["default"] */ .Z,
-    'mercado': _src_mercado_js__WEBPACK_IMPORTED_MODULE_80__/* ["default"] */ .Z,
-    'mexc': _src_mexc_js__WEBPACK_IMPORTED_MODULE_81__/* ["default"] */ .Z,
-    'mexc3': _src_mexc3_js__WEBPACK_IMPORTED_MODULE_82__/* ["default"] */ .Z,
-    'ndax': _src_ndax_js__WEBPACK_IMPORTED_MODULE_83__/* ["default"] */ .Z,
-    'novadax': _src_novadax_js__WEBPACK_IMPORTED_MODULE_84__/* ["default"] */ .Z,
-    'oceanex': _src_oceanex_js__WEBPACK_IMPORTED_MODULE_85__/* ["default"] */ .Z,
-    'okcoin': _src_okcoin_js__WEBPACK_IMPORTED_MODULE_86__/* ["default"] */ .Z,
-    'okex': _src_okex_js__WEBPACK_IMPORTED_MODULE_87__/* ["default"] */ .Z,
-    'okex5': _src_okex5_js__WEBPACK_IMPORTED_MODULE_88__/* ["default"] */ .Z,
-    'okx': _src_okx_js__WEBPACK_IMPORTED_MODULE_89__/* ["default"] */ .Z,
-    'paymium': _src_paymium_js__WEBPACK_IMPORTED_MODULE_90__/* ["default"] */ .Z,
-    'phemex': _src_phemex_js__WEBPACK_IMPORTED_MODULE_91__/* ["default"] */ .Z,
-    'poloniex': _src_poloniex_js__WEBPACK_IMPORTED_MODULE_92__/* ["default"] */ .Z,
-    'poloniexfutures': _src_poloniexfutures_js__WEBPACK_IMPORTED_MODULE_93__/* ["default"] */ .Z,
-    'probit': _src_probit_js__WEBPACK_IMPORTED_MODULE_94__/* ["default"] */ .Z,
-    'tidex': _src_tidex_js__WEBPACK_IMPORTED_MODULE_95__/* ["default"] */ .Z,
-    'timex': _src_timex_js__WEBPACK_IMPORTED_MODULE_96__/* ["default"] */ .Z,
-    'tokocrypto': _src_tokocrypto_js__WEBPACK_IMPORTED_MODULE_97__/* ["default"] */ .Z,
-    'upbit': _src_upbit_js__WEBPACK_IMPORTED_MODULE_98__/* ["default"] */ .Z,
-    'wavesexchange': _src_wavesexchange_js__WEBPACK_IMPORTED_MODULE_99__/* ["default"] */ .Z,
-    'wazirx': _src_wazirx_js__WEBPACK_IMPORTED_MODULE_100__/* ["default"] */ .Z,
-    'whitebit': _src_whitebit_js__WEBPACK_IMPORTED_MODULE_101__/* ["default"] */ .Z,
-    'woo': _src_woo_js__WEBPACK_IMPORTED_MODULE_102__/* ["default"] */ .Z,
-    'yobit': _src_yobit_js__WEBPACK_IMPORTED_MODULE_103__/* ["default"] */ .Z,
-    'zaif': _src_zaif_js__WEBPACK_IMPORTED_MODULE_104__/* ["default"] */ .Z,
-    'zonda': _src_zonda_js__WEBPACK_IMPORTED_MODULE_105__/* ["default"] */ .Z,
+    'coinlist': _src_coinlist_js__WEBPACK_IMPORTED_MODULE_47__/* ["default"] */ .Z,
+    'coinmate': _src_coinmate_js__WEBPACK_IMPORTED_MODULE_48__/* ["default"] */ .Z,
+    'coinone': _src_coinone_js__WEBPACK_IMPORTED_MODULE_49__/* ["default"] */ .Z,
+    'coinsph': _src_coinsph_js__WEBPACK_IMPORTED_MODULE_50__/* ["default"] */ .Z,
+    'coinspot': _src_coinspot_js__WEBPACK_IMPORTED_MODULE_51__/* ["default"] */ .Z,
+    'cryptocom': _src_cryptocom_js__WEBPACK_IMPORTED_MODULE_52__/* ["default"] */ .Z,
+    'currencycom': _src_currencycom_js__WEBPACK_IMPORTED_MODULE_53__/* ["default"] */ .Z,
+    'delta': _src_delta_js__WEBPACK_IMPORTED_MODULE_54__/* ["default"] */ .Z,
+    'deribit': _src_deribit_js__WEBPACK_IMPORTED_MODULE_55__/* ["default"] */ .Z,
+    'digifinex': _src_digifinex_js__WEBPACK_IMPORTED_MODULE_56__/* ["default"] */ .Z,
+    'exmo': _src_exmo_js__WEBPACK_IMPORTED_MODULE_57__/* ["default"] */ .Z,
+    'fmfwio': _src_fmfwio_js__WEBPACK_IMPORTED_MODULE_58__/* ["default"] */ .Z,
+    'gate': _src_gate_js__WEBPACK_IMPORTED_MODULE_59__/* ["default"] */ .Z,
+    'gateio': _src_gateio_js__WEBPACK_IMPORTED_MODULE_60__/* ["default"] */ .Z,
+    'gemini': _src_gemini_js__WEBPACK_IMPORTED_MODULE_61__/* ["default"] */ .Z,
+    'hitbtc': _src_hitbtc_js__WEBPACK_IMPORTED_MODULE_62__/* ["default"] */ .Z,
+    'hitbtc3': _src_hitbtc3_js__WEBPACK_IMPORTED_MODULE_63__/* ["default"] */ .Z,
+    'hollaex': _src_hollaex_js__WEBPACK_IMPORTED_MODULE_64__/* ["default"] */ .Z,
+    'huobi': _src_huobi_js__WEBPACK_IMPORTED_MODULE_65__/* ["default"] */ .Z,
+    'huobijp': _src_huobijp_js__WEBPACK_IMPORTED_MODULE_66__/* ["default"] */ .Z,
+    'huobipro': _src_huobipro_js__WEBPACK_IMPORTED_MODULE_67__/* ["default"] */ .Z,
+    'idex': _src_idex_js__WEBPACK_IMPORTED_MODULE_68__/* ["default"] */ .Z,
+    'independentreserve': _src_independentreserve_js__WEBPACK_IMPORTED_MODULE_69__/* ["default"] */ .Z,
+    'indodax': _src_indodax_js__WEBPACK_IMPORTED_MODULE_70__/* ["default"] */ .Z,
+    'kraken': _src_kraken_js__WEBPACK_IMPORTED_MODULE_71__/* ["default"] */ .Z,
+    'krakenfutures': _src_krakenfutures_js__WEBPACK_IMPORTED_MODULE_72__/* ["default"] */ .Z,
+    'kucoin': _src_kucoin_js__WEBPACK_IMPORTED_MODULE_73__/* ["default"] */ .Z,
+    'kucoinfutures': _src_kucoinfutures_js__WEBPACK_IMPORTED_MODULE_74__/* ["default"] */ .Z,
+    'kuna': _src_kuna_js__WEBPACK_IMPORTED_MODULE_75__/* ["default"] */ .Z,
+    'latoken': _src_latoken_js__WEBPACK_IMPORTED_MODULE_76__/* ["default"] */ .Z,
+    'lbank': _src_lbank_js__WEBPACK_IMPORTED_MODULE_77__/* ["default"] */ .Z,
+    'lbank2': _src_lbank2_js__WEBPACK_IMPORTED_MODULE_78__/* ["default"] */ .Z,
+    'luno': _src_luno_js__WEBPACK_IMPORTED_MODULE_79__/* ["default"] */ .Z,
+    'lykke': _src_lykke_js__WEBPACK_IMPORTED_MODULE_80__/* ["default"] */ .Z,
+    'mercado': _src_mercado_js__WEBPACK_IMPORTED_MODULE_81__/* ["default"] */ .Z,
+    'mexc': _src_mexc_js__WEBPACK_IMPORTED_MODULE_82__/* ["default"] */ .Z,
+    'mexc3': _src_mexc3_js__WEBPACK_IMPORTED_MODULE_83__/* ["default"] */ .Z,
+    'ndax': _src_ndax_js__WEBPACK_IMPORTED_MODULE_84__/* ["default"] */ .Z,
+    'novadax': _src_novadax_js__WEBPACK_IMPORTED_MODULE_85__/* ["default"] */ .Z,
+    'oceanex': _src_oceanex_js__WEBPACK_IMPORTED_MODULE_86__/* ["default"] */ .Z,
+    'okcoin': _src_okcoin_js__WEBPACK_IMPORTED_MODULE_87__/* ["default"] */ .Z,
+    'okex': _src_okex_js__WEBPACK_IMPORTED_MODULE_88__/* ["default"] */ .Z,
+    'okex5': _src_okex5_js__WEBPACK_IMPORTED_MODULE_89__/* ["default"] */ .Z,
+    'okx': _src_okx_js__WEBPACK_IMPORTED_MODULE_90__/* ["default"] */ .Z,
+    'paymium': _src_paymium_js__WEBPACK_IMPORTED_MODULE_91__/* ["default"] */ .Z,
+    'phemex': _src_phemex_js__WEBPACK_IMPORTED_MODULE_92__/* ["default"] */ .Z,
+    'poloniex': _src_poloniex_js__WEBPACK_IMPORTED_MODULE_93__/* ["default"] */ .Z,
+    'poloniexfutures': _src_poloniexfutures_js__WEBPACK_IMPORTED_MODULE_94__/* ["default"] */ .Z,
+    'probit': _src_probit_js__WEBPACK_IMPORTED_MODULE_95__/* ["default"] */ .Z,
+    'tidex': _src_tidex_js__WEBPACK_IMPORTED_MODULE_96__/* ["default"] */ .Z,
+    'timex': _src_timex_js__WEBPACK_IMPORTED_MODULE_97__/* ["default"] */ .Z,
+    'tokocrypto': _src_tokocrypto_js__WEBPACK_IMPORTED_MODULE_98__/* ["default"] */ .Z,
+    'upbit': _src_upbit_js__WEBPACK_IMPORTED_MODULE_99__/* ["default"] */ .Z,
+    'wavesexchange': _src_wavesexchange_js__WEBPACK_IMPORTED_MODULE_100__/* ["default"] */ .Z,
+    'wazirx': _src_wazirx_js__WEBPACK_IMPORTED_MODULE_101__/* ["default"] */ .Z,
+    'whitebit': _src_whitebit_js__WEBPACK_IMPORTED_MODULE_102__/* ["default"] */ .Z,
+    'woo': _src_woo_js__WEBPACK_IMPORTED_MODULE_103__/* ["default"] */ .Z,
+    'yobit': _src_yobit_js__WEBPACK_IMPORTED_MODULE_104__/* ["default"] */ .Z,
+    'zaif': _src_zaif_js__WEBPACK_IMPORTED_MODULE_105__/* ["default"] */ .Z,
+    'zonda': _src_zonda_js__WEBPACK_IMPORTED_MODULE_106__/* ["default"] */ .Z,
 };
 const pro = {
-    'alpaca': _src_pro_alpaca_js__WEBPACK_IMPORTED_MODULE_106__/* ["default"] */ .Z,
-    'ascendex': _src_pro_ascendex_js__WEBPACK_IMPORTED_MODULE_107__/* ["default"] */ .Z,
-    'bequant': _src_pro_bequant_js__WEBPACK_IMPORTED_MODULE_108__/* ["default"] */ .Z,
-    'binance': _src_pro_binance_js__WEBPACK_IMPORTED_MODULE_109__/* ["default"] */ .Z,
-    'binancecoinm': _src_pro_binancecoinm_js__WEBPACK_IMPORTED_MODULE_110__/* ["default"] */ .Z,
-    'binanceus': _src_pro_binanceus_js__WEBPACK_IMPORTED_MODULE_111__/* ["default"] */ .Z,
-    'binanceusdm': _src_pro_binanceusdm_js__WEBPACK_IMPORTED_MODULE_112__/* ["default"] */ .Z,
-    'bingx': _src_pro_bingx_js__WEBPACK_IMPORTED_MODULE_113__/* ["default"] */ .Z,
-    'bitcoincom': _src_pro_bitcoincom_js__WEBPACK_IMPORTED_MODULE_114__/* ["default"] */ .Z,
-    'bitfinex': _src_pro_bitfinex_js__WEBPACK_IMPORTED_MODULE_115__/* ["default"] */ .Z,
-    'bitfinex2': _src_pro_bitfinex2_js__WEBPACK_IMPORTED_MODULE_116__/* ["default"] */ .Z,
-    'bitget': _src_pro_bitget_js__WEBPACK_IMPORTED_MODULE_117__/* ["default"] */ .Z,
-    'bitmart': _src_pro_bitmart_js__WEBPACK_IMPORTED_MODULE_118__/* ["default"] */ .Z,
-    'bitmex': _src_pro_bitmex_js__WEBPACK_IMPORTED_MODULE_119__/* ["default"] */ .Z,
-    'bitopro': _src_pro_bitopro_js__WEBPACK_IMPORTED_MODULE_120__/* ["default"] */ .Z,
-    'bitpanda': _src_pro_bitpanda_js__WEBPACK_IMPORTED_MODULE_121__/* ["default"] */ .Z,
-    'bitrue': _src_pro_bitrue_js__WEBPACK_IMPORTED_MODULE_122__/* ["default"] */ .Z,
-    'bitstamp': _src_pro_bitstamp_js__WEBPACK_IMPORTED_MODULE_123__/* ["default"] */ .Z,
-    'bittrex': _src_pro_bittrex_js__WEBPACK_IMPORTED_MODULE_124__/* ["default"] */ .Z,
-    'bitvavo': _src_pro_bitvavo_js__WEBPACK_IMPORTED_MODULE_125__/* ["default"] */ .Z,
-    'blockchaincom': _src_pro_blockchaincom_js__WEBPACK_IMPORTED_MODULE_126__/* ["default"] */ .Z,
-    'bybit': _src_pro_bybit_js__WEBPACK_IMPORTED_MODULE_127__/* ["default"] */ .Z,
-    'cex': _src_pro_cex_js__WEBPACK_IMPORTED_MODULE_128__/* ["default"] */ .Z,
-    'coinbase': _src_pro_coinbase_js__WEBPACK_IMPORTED_MODULE_129__/* ["default"] */ .Z,
-    'coinbaseprime': _src_pro_coinbaseprime_js__WEBPACK_IMPORTED_MODULE_130__/* ["default"] */ .Z,
-    'coinbasepro': _src_pro_coinbasepro_js__WEBPACK_IMPORTED_MODULE_131__/* ["default"] */ .Z,
-    'coinex': _src_pro_coinex_js__WEBPACK_IMPORTED_MODULE_132__/* ["default"] */ .Z,
-    'cryptocom': _src_pro_cryptocom_js__WEBPACK_IMPORTED_MODULE_133__/* ["default"] */ .Z,
-    'currencycom': _src_pro_currencycom_js__WEBPACK_IMPORTED_MODULE_134__/* ["default"] */ .Z,
-    'deribit': _src_pro_deribit_js__WEBPACK_IMPORTED_MODULE_135__/* ["default"] */ .Z,
-    'exmo': _src_pro_exmo_js__WEBPACK_IMPORTED_MODULE_136__/* ["default"] */ .Z,
-    'gate': _src_pro_gate_js__WEBPACK_IMPORTED_MODULE_137__/* ["default"] */ .Z,
-    'gateio': _src_pro_gateio_js__WEBPACK_IMPORTED_MODULE_138__/* ["default"] */ .Z,
-    'gemini': _src_pro_gemini_js__WEBPACK_IMPORTED_MODULE_139__/* ["default"] */ .Z,
-    'hitbtc': _src_pro_hitbtc_js__WEBPACK_IMPORTED_MODULE_140__/* ["default"] */ .Z,
-    'hollaex': _src_pro_hollaex_js__WEBPACK_IMPORTED_MODULE_141__/* ["default"] */ .Z,
-    'huobi': _src_pro_huobi_js__WEBPACK_IMPORTED_MODULE_142__/* ["default"] */ .Z,
-    'huobijp': _src_pro_huobijp_js__WEBPACK_IMPORTED_MODULE_143__/* ["default"] */ .Z,
-    'huobipro': _src_pro_huobipro_js__WEBPACK_IMPORTED_MODULE_144__/* ["default"] */ .Z,
-    'idex': _src_pro_idex_js__WEBPACK_IMPORTED_MODULE_145__/* ["default"] */ .Z,
-    'independentreserve': _src_pro_independentreserve_js__WEBPACK_IMPORTED_MODULE_146__/* ["default"] */ .Z,
-    'kraken': _src_pro_kraken_js__WEBPACK_IMPORTED_MODULE_147__/* ["default"] */ .Z,
-    'krakenfutures': _src_pro_krakenfutures_js__WEBPACK_IMPORTED_MODULE_148__/* ["default"] */ .Z,
-    'kucoin': _src_pro_kucoin_js__WEBPACK_IMPORTED_MODULE_149__/* ["default"] */ .Z,
-    'kucoinfutures': _src_pro_kucoinfutures_js__WEBPACK_IMPORTED_MODULE_150__/* ["default"] */ .Z,
-    'luno': _src_pro_luno_js__WEBPACK_IMPORTED_MODULE_151__/* ["default"] */ .Z,
-    'mexc': _src_pro_mexc_js__WEBPACK_IMPORTED_MODULE_152__/* ["default"] */ .Z,
-    'mexc3': _src_pro_mexc3_js__WEBPACK_IMPORTED_MODULE_153__/* ["default"] */ .Z,
-    'ndax': _src_pro_ndax_js__WEBPACK_IMPORTED_MODULE_154__/* ["default"] */ .Z,
-    'okcoin': _src_pro_okcoin_js__WEBPACK_IMPORTED_MODULE_155__/* ["default"] */ .Z,
-    'okex': _src_pro_okex_js__WEBPACK_IMPORTED_MODULE_156__/* ["default"] */ .Z,
-    'okx': _src_pro_okx_js__WEBPACK_IMPORTED_MODULE_157__/* ["default"] */ .Z,
-    'phemex': _src_pro_phemex_js__WEBPACK_IMPORTED_MODULE_158__/* ["default"] */ .Z,
-    'poloniex': _src_pro_poloniex_js__WEBPACK_IMPORTED_MODULE_159__/* ["default"] */ .Z,
-    'poloniexfutures': _src_pro_poloniexfutures_js__WEBPACK_IMPORTED_MODULE_160__/* ["default"] */ .Z,
-    'probit': _src_pro_probit_js__WEBPACK_IMPORTED_MODULE_161__/* ["default"] */ .Z,
-    'upbit': _src_pro_upbit_js__WEBPACK_IMPORTED_MODULE_162__/* ["default"] */ .Z,
-    'wazirx': _src_pro_wazirx_js__WEBPACK_IMPORTED_MODULE_163__/* ["default"] */ .Z,
-    'whitebit': _src_pro_whitebit_js__WEBPACK_IMPORTED_MODULE_164__/* ["default"] */ .Z,
-    'woo': _src_pro_woo_js__WEBPACK_IMPORTED_MODULE_165__/* ["default"] */ .Z,
+    'alpaca': _src_pro_alpaca_js__WEBPACK_IMPORTED_MODULE_107__/* ["default"] */ .Z,
+    'ascendex': _src_pro_ascendex_js__WEBPACK_IMPORTED_MODULE_108__/* ["default"] */ .Z,
+    'bequant': _src_pro_bequant_js__WEBPACK_IMPORTED_MODULE_109__/* ["default"] */ .Z,
+    'binance': _src_pro_binance_js__WEBPACK_IMPORTED_MODULE_110__/* ["default"] */ .Z,
+    'binancecoinm': _src_pro_binancecoinm_js__WEBPACK_IMPORTED_MODULE_111__/* ["default"] */ .Z,
+    'binanceus': _src_pro_binanceus_js__WEBPACK_IMPORTED_MODULE_112__/* ["default"] */ .Z,
+    'binanceusdm': _src_pro_binanceusdm_js__WEBPACK_IMPORTED_MODULE_113__/* ["default"] */ .Z,
+    'bingx': _src_pro_bingx_js__WEBPACK_IMPORTED_MODULE_114__/* ["default"] */ .Z,
+    'bitcoincom': _src_pro_bitcoincom_js__WEBPACK_IMPORTED_MODULE_115__/* ["default"] */ .Z,
+    'bitfinex': _src_pro_bitfinex_js__WEBPACK_IMPORTED_MODULE_116__/* ["default"] */ .Z,
+    'bitfinex2': _src_pro_bitfinex2_js__WEBPACK_IMPORTED_MODULE_117__/* ["default"] */ .Z,
+    'bitget': _src_pro_bitget_js__WEBPACK_IMPORTED_MODULE_118__/* ["default"] */ .Z,
+    'bitmart': _src_pro_bitmart_js__WEBPACK_IMPORTED_MODULE_119__/* ["default"] */ .Z,
+    'bitmex': _src_pro_bitmex_js__WEBPACK_IMPORTED_MODULE_120__/* ["default"] */ .Z,
+    'bitopro': _src_pro_bitopro_js__WEBPACK_IMPORTED_MODULE_121__/* ["default"] */ .Z,
+    'bitpanda': _src_pro_bitpanda_js__WEBPACK_IMPORTED_MODULE_122__/* ["default"] */ .Z,
+    'bitrue': _src_pro_bitrue_js__WEBPACK_IMPORTED_MODULE_123__/* ["default"] */ .Z,
+    'bitstamp': _src_pro_bitstamp_js__WEBPACK_IMPORTED_MODULE_124__/* ["default"] */ .Z,
+    'bittrex': _src_pro_bittrex_js__WEBPACK_IMPORTED_MODULE_125__/* ["default"] */ .Z,
+    'bitvavo': _src_pro_bitvavo_js__WEBPACK_IMPORTED_MODULE_126__/* ["default"] */ .Z,
+    'blockchaincom': _src_pro_blockchaincom_js__WEBPACK_IMPORTED_MODULE_127__/* ["default"] */ .Z,
+    'bybit': _src_pro_bybit_js__WEBPACK_IMPORTED_MODULE_128__/* ["default"] */ .Z,
+    'cex': _src_pro_cex_js__WEBPACK_IMPORTED_MODULE_129__/* ["default"] */ .Z,
+    'coinbase': _src_pro_coinbase_js__WEBPACK_IMPORTED_MODULE_130__/* ["default"] */ .Z,
+    'coinbaseprime': _src_pro_coinbaseprime_js__WEBPACK_IMPORTED_MODULE_131__/* ["default"] */ .Z,
+    'coinbasepro': _src_pro_coinbasepro_js__WEBPACK_IMPORTED_MODULE_132__/* ["default"] */ .Z,
+    'coinex': _src_pro_coinex_js__WEBPACK_IMPORTED_MODULE_133__/* ["default"] */ .Z,
+    'cryptocom': _src_pro_cryptocom_js__WEBPACK_IMPORTED_MODULE_134__/* ["default"] */ .Z,
+    'currencycom': _src_pro_currencycom_js__WEBPACK_IMPORTED_MODULE_135__/* ["default"] */ .Z,
+    'deribit': _src_pro_deribit_js__WEBPACK_IMPORTED_MODULE_136__/* ["default"] */ .Z,
+    'exmo': _src_pro_exmo_js__WEBPACK_IMPORTED_MODULE_137__/* ["default"] */ .Z,
+    'gate': _src_pro_gate_js__WEBPACK_IMPORTED_MODULE_138__/* ["default"] */ .Z,
+    'gateio': _src_pro_gateio_js__WEBPACK_IMPORTED_MODULE_139__/* ["default"] */ .Z,
+    'gemini': _src_pro_gemini_js__WEBPACK_IMPORTED_MODULE_140__/* ["default"] */ .Z,
+    'hitbtc': _src_pro_hitbtc_js__WEBPACK_IMPORTED_MODULE_141__/* ["default"] */ .Z,
+    'hollaex': _src_pro_hollaex_js__WEBPACK_IMPORTED_MODULE_142__/* ["default"] */ .Z,
+    'huobi': _src_pro_huobi_js__WEBPACK_IMPORTED_MODULE_143__/* ["default"] */ .Z,
+    'huobijp': _src_pro_huobijp_js__WEBPACK_IMPORTED_MODULE_144__/* ["default"] */ .Z,
+    'huobipro': _src_pro_huobipro_js__WEBPACK_IMPORTED_MODULE_145__/* ["default"] */ .Z,
+    'idex': _src_pro_idex_js__WEBPACK_IMPORTED_MODULE_146__/* ["default"] */ .Z,
+    'independentreserve': _src_pro_independentreserve_js__WEBPACK_IMPORTED_MODULE_147__/* ["default"] */ .Z,
+    'kraken': _src_pro_kraken_js__WEBPACK_IMPORTED_MODULE_148__/* ["default"] */ .Z,
+    'krakenfutures': _src_pro_krakenfutures_js__WEBPACK_IMPORTED_MODULE_149__/* ["default"] */ .Z,
+    'kucoin': _src_pro_kucoin_js__WEBPACK_IMPORTED_MODULE_150__/* ["default"] */ .Z,
+    'kucoinfutures': _src_pro_kucoinfutures_js__WEBPACK_IMPORTED_MODULE_151__/* ["default"] */ .Z,
+    'luno': _src_pro_luno_js__WEBPACK_IMPORTED_MODULE_152__/* ["default"] */ .Z,
+    'mexc': _src_pro_mexc_js__WEBPACK_IMPORTED_MODULE_153__/* ["default"] */ .Z,
+    'mexc3': _src_pro_mexc3_js__WEBPACK_IMPORTED_MODULE_154__/* ["default"] */ .Z,
+    'ndax': _src_pro_ndax_js__WEBPACK_IMPORTED_MODULE_155__/* ["default"] */ .Z,
+    'okcoin': _src_pro_okcoin_js__WEBPACK_IMPORTED_MODULE_156__/* ["default"] */ .Z,
+    'okex': _src_pro_okex_js__WEBPACK_IMPORTED_MODULE_157__/* ["default"] */ .Z,
+    'okx': _src_pro_okx_js__WEBPACK_IMPORTED_MODULE_158__/* ["default"] */ .Z,
+    'phemex': _src_pro_phemex_js__WEBPACK_IMPORTED_MODULE_159__/* ["default"] */ .Z,
+    'poloniex': _src_pro_poloniex_js__WEBPACK_IMPORTED_MODULE_160__/* ["default"] */ .Z,
+    'poloniexfutures': _src_pro_poloniexfutures_js__WEBPACK_IMPORTED_MODULE_161__/* ["default"] */ .Z,
+    'probit': _src_pro_probit_js__WEBPACK_IMPORTED_MODULE_162__/* ["default"] */ .Z,
+    'upbit': _src_pro_upbit_js__WEBPACK_IMPORTED_MODULE_163__/* ["default"] */ .Z,
+    'wazirx': _src_pro_wazirx_js__WEBPACK_IMPORTED_MODULE_164__/* ["default"] */ .Z,
+    'whitebit': _src_pro_whitebit_js__WEBPACK_IMPORTED_MODULE_165__/* ["default"] */ .Z,
+    'woo': _src_pro_woo_js__WEBPACK_IMPORTED_MODULE_166__/* ["default"] */ .Z,
 };
 for (const exchange in pro) {
     // const ccxtExchange = exchanges[exchange]
@@ -282147,7 +284668,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_166__/* .Precise */ .O, 'exchanges': Object.keys(exchanges), 'pro': pro }, exchanges, _src_base_functions_js__WEBPACK_IMPORTED_MODULE_167__, _src_base_errors_js__WEBPACK_IMPORTED_MODULE_168__);
+const ccxt = Object.assign({ version, Exchange: _src_base_Exchange_js__WEBPACK_IMPORTED_MODULE_0__/* .Exchange */ .e, Precise: _src_base_Precise_js__WEBPACK_IMPORTED_MODULE_167__/* .Precise */ .O, 'exchanges': Object.keys(exchanges), 'pro': pro }, exchanges, _src_base_functions_js__WEBPACK_IMPORTED_MODULE_168__, _src_base_errors_js__WEBPACK_IMPORTED_MODULE_169__);
 
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (ccxt);
 //-----------------------------------------------------------------------------