ccxt 4.2.38 → 4.2.40

package/js/src/poloniexfutures.js

@@ -1705,13 +1705,13 @@ export default class poloniexfutures extends Exchange {
         const trades = this.safeValue(data, 'items', {});
         return this.parseTrades(trades, market, since, limit);
     }
-    async setMarginMode(marginMode, symbol, params = {}) {
+    async setMarginMode(marginMode, symbol = undefined, params = {}) {
         /**
          * @method
          * @name poloniexfutures#setMarginMode
          * @description set margin mode to 'cross' or 'isolated'
          * @see https://futures-docs.poloniex.com/#change-margin-mode
-         * @param {int} marginMode 0 (isolated) or 1 (cross)
+         * @param {string} marginMode "0" (isolated) or "1" (cross)
          * @param {string} symbol unified market symbol
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @returns {object} response from the exchange
@@ -1719,14 +1719,20 @@ export default class poloniexfutures extends Exchange {
         if (symbol === undefined) {
             throw new ArgumentsRequired(this.id + ' setMarginMode() requires a symbol argument');
         }
-        if ((marginMode !== 0) && (marginMode !== 1)) {
-            throw new ArgumentsRequired(this.id + ' setMarginMode() marginMode must be 0 (isolated) or 1 (cross)');
+        if ((marginMode !== '0') && (marginMode !== '1') && (marginMode !== 'isolated') && (marginMode !== 'cross')) {
+            throw new ArgumentsRequired(this.id + ' setMarginMode() marginMode must be 0/isolated or 1/cross');
         }
         await this.loadMarkets();
+        if (marginMode === 'isolated') {
+            marginMode = '0';
+        }
+        if (marginMode === 'cross') {
+            marginMode = '1';
+        }
         const market = this.market(symbol);
         const request = {
             'symbol': market['id'],
-            'marginType': marginMode,
+            'marginType': this.parseToInt(marginMode),
         };
         return await this.privatePostMarginTypeChange(request);
     }

package/js/src/pro/bitmart.d.ts

@@ -4,11 +4,14 @@ import Client from '../base/ws/Client.js';
 export default class bitmart extends bitmartRest {
     describe(): any;
     subscribe(channel: any, symbol: any, type: any, params?: {}): Promise<any>;
+    subscribeMultiple(channel: string, type: string, symbols: string[], params?: {}): Promise<any>;
     watchBalance(params?: {}): Promise<Balances>;
     setBalanceCache(client: Client, type: any, subscribeHash: any): void;
     loadBalanceSnapshot(client: any, messageHash: any, type: any): Promise<void>;
     handleBalance(client: Client, message: any): void;
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    watchTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    getParamsForMultipleSub(methodName: string, symbols: string[], limit?: Int, params?: {}): any[];
     watchTicker(symbol: string, params?: {}): Promise<Ticker>;
     watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
@@ -31,6 +34,7 @@ export default class bitmart extends bitmartRest {
     handleDeltas(bookside: any, deltas: any): void;
     handleOrderBookMessage(client: Client, message: any, orderbook: any): any;
     handleOrderBook(client: Client, message: any): void;
+    watchOrderBookForSymbols(symbols: string[], limit?: Int, params?: {}): Promise<OrderBook>;
     authenticate(type: any, params?: {}): Promise<any>;
     handleSubscriptionStatus(client: Client, message: any): any;
     handleAuthenticate(client: Client, message: any): void;

package/js/src/pro/bitmart.js

@@ -27,8 +27,10 @@ export default class bitmart extends bitmartRest {
                 'watchTicker': true,
                 'watchTickers': true,
                 'watchOrderBook': true,
+                'watchOrderBookForSymbols': true,
                 'watchOrders': true,
                 'watchTrades': true,
+                'watchTradesForSymbols': true,
                 'watchOHLCV': true,
                 'watchPosition': 'emulated',
                 'watchPositions': true,
@@ -53,8 +55,15 @@ export default class bitmart extends bitmartRest {
                     'fetchBalanceSnapshot': true,
                     'awaitBalanceSnapshot': false, // whether to wait for the balance snapshot before providing updates
                 },
+                //
+                // orderbook channels can have:
+                //  -  'depth5', 'depth20', 'depth50' // these endpoints emit full Orderbooks once in every 500ms
+                //  -  'depth/increase100' // this endpoint is preferred, because it emits once in 100ms. however, when this value is chosen, it only affects spot-market, but contracts markets automatically `depth50` will be being used
                 'watchOrderBook': {
-                    'depth': 'depth/increase100', // depth/increase100, depth5, depth20, depth50
+                    'depth': 'depth/increase100',
+                },
+                'watchOrderBookForSymbols': {
+                    'depth': 'depth/increase100',
                 },
                 'ws': {
                     'inflate': true,
@@ -101,6 +110,24 @@ export default class bitmart extends bitmartRest {
         }
         return await this.watch(url, messageHash, this.deepExtend(request, params), messageHash);
     }
+    async subscribeMultiple(channel, type, symbols, params = {}) {
+        const url = this.implodeHostname(this.urls['api']['ws'][type]['public']);
+        const channelType = (type === 'spot') ? 'spot' : 'futures';
+        const actionType = (type === 'spot') ? 'op' : 'action';
+        const rawSubscriptions = [];
+        const messageHashes = [];
+        for (let i = 0; i < symbols.length; i++) {
+            const market = this.market(symbols[i]);
+            const message = channelType + '/' + channel + ':' + market['id'];
+            rawSubscriptions.push(message);
+            messageHashes.push(channel + ':' + market['symbol']);
+        }
+        const request = {
+            'args': rawSubscriptions,
+        };
+        request[actionType] = 'subscribe';
+        return await this.watchMultiple(url, messageHashes, this.deepExtend(request, params), rawSubscriptions);
+    }
     async watchBalance(params = {}) {
         /**
          * @method
@@ -248,17 +275,43 @@ export default class bitmart extends bitmartRest {
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades}
          */
+        return await this.watchTradesForSymbols([symbol], since, limit, params);
+    }
+    async watchTradesForSymbols(symbols, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name bitmart#watchTradesForSymbols
+         * @see https://developer-pro.bitmart.com/en/spot/#public-trade-channel
+         * @description get the list of most recent trades for a list of symbols
+         * @param {string[]} symbols unified symbol of the market to fetch trades for
+         * @param {int} [since] timestamp in ms of the earliest trade to fetch
+         * @param {int} [limit] the maximum amount of trades to fetch
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades}
+         */
         await this.loadMarkets();
-        symbol = this.symbol(symbol);
-        const market = this.market(symbol);
-        let type = 'spot';
-        [type, params] = this.handleMarketTypeAndParams('watchTrades', market, params);
-        const trades = await this.subscribe('trade', symbol, type, params);
+        let marketType = undefined;
+        [symbols, marketType, params] = this.getParamsForMultipleSub('watchTradesForSymbols', symbols, limit, params);
+        const channelName = 'trade';
+        const trades = await this.subscribeMultiple(channelName, marketType, symbols, params);
         if (this.newUpdates) {
-            limit = trades.getLimit(symbol, limit);
+            const first = this.safeDict(trades, 0);
+            const tradeSymbol = this.safeString(first, 'symbol');
+            limit = trades.getLimit(tradeSymbol, limit);
         }
         return this.filterBySinceLimit(trades, since, limit, 'timestamp', true);
     }
+    getParamsForMultipleSub(methodName, symbols, limit = undefined, params = {}) {
+        symbols = this.marketSymbols(symbols, undefined, false, true);
+        const length = symbols.length;
+        if (length > 20) {
+            throw new NotSupported(this.id + ' ' + methodName + '() accepts a maximum of 20 symbols in one request');
+        }
+        const market = this.market(symbols[0]);
+        let marketType = undefined;
+        [marketType, params] = this.handleMarketTypeAndParams(methodName, market, params);
+        return [symbols, marketType, params];
+    }
     async watchTicker(symbol, params = {}) {
         /**
          * @method
@@ -796,16 +849,15 @@ export default class bitmart extends bitmartRest {
         //        ]
         //    }
         //
-        const channel = this.safeString2(message, 'table', 'group');
-        const isSpot = (channel.indexOf('spot') >= 0);
         const data = this.safeValue(message, 'data');
         if (data === undefined) {
             return;
         }
         let stored = undefined;
+        let symbol = undefined;
         for (let i = 0; i < data.length; i++) {
             const trade = this.parseWsTrade(data[i]);
-            const symbol = trade['symbol'];
+            symbol = trade['symbol'];
             const tradesLimit = this.safeInteger(this.options, 'tradesLimit', 1000);
             stored = this.safeValue(this.trades, symbol);
             if (stored === undefined) {
@@ -814,10 +866,7 @@ export default class bitmart extends bitmartRest {
             }
             stored.append(trade);
         }
-        let messageHash = channel;
-        if (isSpot) {
-            messageHash += ':' + this.safeString(data[0], 'symbol');
-        }
+        const messageHash = 'trade:' + symbol;
         client.resolve(stored, messageHash);
     }
     parseWsTrade(trade, market = undefined) {
@@ -1159,8 +1208,8 @@ export default class bitmart extends bitmartRest {
         //         "symbol": "BTC_USDT"
         //     }
         //
-        const asks = this.safeValue(message, 'asks', []);
-        const bids = this.safeValue(message, 'bids', []);
+        const asks = this.safeList(message, 'asks', []);
+        const bids = this.safeList(message, 'bids', []);
         this.handleDeltas(orderbook['asks'], asks);
         this.handleDeltas(orderbook['bids'], bids);
         const timestamp = this.safeInteger(message, 'ms_t');
@@ -1174,6 +1223,7 @@ export default class bitmart extends bitmartRest {
     handleOrderBook(client, message) {
         //
         // spot depth-all
+        //
         //    {
         //        "data": [
         //            {
@@ -1193,33 +1243,31 @@ export default class bitmart extends bitmartRest {
         //        ],
         //        "table": "spot/depth5"
         //    }
+        //
         // spot increse depth snapshot
+        //
         //    {
         //        "data":[
         //           {
-        //              "asks":[
-        //                 [
-        //                    "43652.52",
-        //                    "0.02039"
-        //                 ],
-        //                 ...
-        //              ],
-        //              "bids":[
-        //                [
-        //                   "43652.51",
-        //                   "0.00500"
+        //               "asks":[
+        //                   [ "43652.52", "0.02039" ],
+        //                   ...
         //                ],
-        //                ...
-        //              ],
-        //              "ms_t":1703376836487,
-        //              "symbol":"BTC_USDT",
-        //              "type":"snapshot", // or update
-        //              "version":2141731
+        //                "bids":[
+        //                   [ "43652.51", "0.00500" ],
+        //                   ...
+        //                ],
+        //                "ms_t":1703376836487,
+        //                "symbol":"BTC_USDT",
+        //                "type":"snapshot", // or update
+        //                "version":2141731
         //           }
         //        ],
         //        "table":"spot/depth/increase100"
         //    }
+        //
         // swap
+        //
         //    {
         //        "group":"futures/depth50:BTCUSDT",
         //        "data":{
@@ -1240,50 +1288,69 @@ export default class bitmart extends bitmartRest {
         //        }
         //    }
         //
-        const data = this.safeValue(message, 'data');
-        if (data === undefined) {
+        const isSpot = ('table' in message);
+        let datas = [];
+        if (isSpot) {
+            datas = this.safeList(message, 'data', datas);
+        }
+        else {
+            const orderBookEntry = this.safeDict(message, 'data');
+            if (orderBookEntry !== undefined) {
+                datas.push(orderBookEntry);
+            }
+        }
+        const length = datas.length;
+        if (length <= 0) {
             return;
         }
-        const depths = this.safeValue(data, 'depths');
-        const isSpot = (depths === undefined);
-        const table = this.safeString2(message, 'table', 'group');
+        const channelName = this.safeString2(message, 'table', 'group');
         // find limit subscribed to
         const limitsToCheck = ['100', '50', '20', '10', '5'];
         let limit = 0;
         for (let i = 0; i < limitsToCheck.length; i++) {
             const limitString = limitsToCheck[i];
-            if (table.indexOf(limitString) >= 0) {
+            if (channelName.indexOf(limitString) >= 0) {
                 limit = this.parseToInt(limitString);
                 break;
             }
         }
         if (isSpot) {
-            for (let i = 0; i < data.length; i++) {
-                const update = data[i];
+            const channel = channelName.replace('spot/', '');
+            for (let i = 0; i < datas.length; i++) {
+                const update = datas[i];
                 const marketId = this.safeString(update, 'symbol');
                 const symbol = this.safeSymbol(marketId);
-                let orderbook = this.safeValue(this.orderbooks, symbol);
+                let orderbook = this.safeDict(this.orderbooks, symbol);
                 if (orderbook === undefined) {
                     orderbook = this.orderBook({}, limit);
                     orderbook['symbol'] = symbol;
                     this.orderbooks[symbol] = orderbook;
                 }
                 const type = this.safeValue(update, 'type');
-                if ((type === 'snapshot') || (!(table.indexOf('increase') >= 0))) {
+                if ((type === 'snapshot') || (!(channelName.indexOf('increase') >= 0))) {
                     orderbook.reset({});
                 }
                 this.handleOrderBookMessage(client, update, orderbook);
                 const timestamp = this.safeInteger(update, 'ms_t');
-                orderbook['timestamp'] = timestamp;
-                orderbook['datetime'] = this.iso8601(timestamp);
-                const messageHash = table + ':' + marketId;
+                if (orderbook['timestamp'] === undefined) {
+                    orderbook['timestamp'] = timestamp;
+                    orderbook['datetime'] = this.iso8601(timestamp);
+                }
+                const messageHash = channelName + ':' + marketId;
                 client.resolve(orderbook, messageHash);
+                // resolve ForSymbols
+                const messageHashForMulti = channel + ':' + symbol;
+                client.resolve(orderbook, messageHashForMulti);
             }
         }
         else {
+            const tableParts = channelName.split(':');
+            const channel = tableParts[0].replace('futures/', '');
+            const data = datas[0]; // contract markets always contain only one member
+            const depths = data['depths'];
             const marketId = this.safeString(data, 'symbol');
             const symbol = this.safeSymbol(marketId);
-            let orderbook = this.safeValue(this.orderbooks, symbol);
+            let orderbook = this.safeDict(this.orderbooks, symbol);
             if (orderbook === undefined) {
                 orderbook = this.orderBook({}, limit);
                 orderbook['symbol'] = symbol;
@@ -1312,10 +1379,36 @@ export default class bitmart extends bitmartRest {
             const timestamp = this.safeInteger(data, 'ms_t');
             orderbook['timestamp'] = timestamp;
             orderbook['datetime'] = this.iso8601(timestamp);
-            const messageHash = table;
+            const messageHash = channelName;
             client.resolve(orderbook, messageHash);
+            // resolve ForSymbols
+            const messageHashForMulti = channel + ':' + symbol;
+            client.resolve(orderbook, messageHashForMulti);
         }
     }
+    async watchOrderBookForSymbols(symbols, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name bitmart#watchOrderBookForSymbols
+         * @description watches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
+         * @see https://developer-pro.bitmart.com/en/spot/#public-depth-increase-channel
+         * @param {string[]} symbols unified array of symbols
+         * @param {int} [limit] the maximum amount of order book entries to return
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {string} [params.depth] the type of order book to subscribe to, default is 'depth/increase100', also accepts 'depth5' or 'depth20' or depth50
+         * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
+         */
+        await this.loadMarkets();
+        let type = undefined;
+        [symbols, type, params] = this.getParamsForMultipleSub('watchOrderBookForSymbols', symbols, limit, params);
+        let channel = undefined;
+        [channel, params] = this.handleOptionAndParams(params, 'watchOrderBookForSymbols', 'depth', 'depth/increase100');
+        if (type === 'swap' && channel === 'depth/increase100') {
+            channel = 'depth50';
+        }
+        const orderbook = await this.subscribeMultiple(channel, type, symbols, params);
+        return orderbook.limit();
+    }
     async authenticate(type, params = {}) {
         this.checkRequiredCredentials();
         const url = this.implodeHostname(this.urls['api']['ws'][type]['private']);

package/js/src/pro/bitvavo.d.ts

@@ -23,7 +23,7 @@ export default class bitvavo extends bitvavoRest {
     watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     createOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, params?: {}): Promise<Order>;
-    editOrderWs(id: string, symbol: any, type: any, side: any, amount?: any, price?: any, params?: {}): Promise<Order>;
+    editOrderWs(id: string, symbol: string, type: OrderType, side: OrderSide, amount?: number, price?: number, params?: {}): Promise<Order>;
     cancelOrderWs(id: string, symbol?: string, params?: {}): Promise<any>;
     cancelAllOrdersWs(symbol?: string, params?: {}): Promise<any>;
     handleMultipleOrders(client: Client, message: any): void;

package/js/src/pro/bybit.d.ts

@@ -4,7 +4,7 @@ import Client from '../base/ws/Client.js';
 export default class bybit extends bybitRest {
     describe(): any;
     requestId(): any;
-    getUrlByMarketType(symbol?: Str, isPrivate?: boolean, method?: any, params?: {}): any;
+    getUrlByMarketType(symbol?: Str, isPrivate?: boolean, method?: string, params?: {}): any;
     cleanParams(params: any): any;
     watchTicker(symbol: string, params?: {}): Promise<Ticker>;
     watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;

package/js/src/pro/bybit.js

@@ -187,7 +187,7 @@ export default class bybit extends bybitRest {
         const market = this.market(symbol);
         symbol = market['symbol'];
         const messageHash = 'ticker:' + symbol;
-        const url = this.getUrlByMarketType(symbol, false, params);
+        const url = this.getUrlByMarketType(symbol, false, 'watchTicker', params);
         params = this.cleanParams(params);
         const options = this.safeValue(this.options, 'watchTicker', {});
         let topic = this.safeString(options, 'name', 'tickers');
@@ -212,7 +212,7 @@ export default class bybit extends bybitRest {
         await this.loadMarkets();
         symbols = this.marketSymbols(symbols, undefined, false);
         const messageHashes = [];
-        const url = this.getUrlByMarketType(symbols[0], false, params);
+        const url = this.getUrlByMarketType(symbols[0], false, 'watchTickers', params);
         params = this.cleanParams(params);
         const options = this.safeValue(this.options, 'watchTickers', {});
         const topic = this.safeString(options, 'name', 'tickers');
@@ -379,7 +379,7 @@ export default class bybit extends bybitRest {
         await this.loadMarkets();
         const market = this.market(symbol);
         symbol = market['symbol'];
-        const url = this.getUrlByMarketType(symbol, false, params);
+        const url = this.getUrlByMarketType(symbol, false, 'watchOHLCV', params);
         params = this.cleanParams(params);
         let ohlcv = undefined;
         const timeframeId = this.safeString(this.timeframes, timeframe, timeframe);
@@ -497,7 +497,7 @@ export default class bybit extends bybitRest {
             throw new ArgumentsRequired(this.id + ' watchOrderBookForSymbols() requires a non-empty array of symbols');
         }
         symbols = this.marketSymbols(symbols);
-        const url = this.getUrlByMarketType(symbols[0], false, params);
+        const url = this.getUrlByMarketType(symbols[0], false, 'watchOrderBook', params);
         params = this.cleanParams(params);
         const market = this.market(symbols[0]);
         if (limit === undefined) {
@@ -629,7 +629,7 @@ export default class bybit extends bybitRest {
             throw new ArgumentsRequired(this.id + ' watchTradesForSymbols() requires a non-empty array of symbols');
         }
         params = this.cleanParams(params);
-        const url = this.getUrlByMarketType(symbols[0], false, params);
+        const url = this.getUrlByMarketType(symbols[0], false, 'watchTrades', params);
         const topics = [];
         const messageHashes = [];
         for (let i = 0; i < symbols.length; i++) {

package/js/src/pro/cex.d.ts

@@ -40,9 +40,9 @@ export default class cex extends cexRest {
     fetchOrderWs(id: string, symbol?: string, params?: {}): Promise<Order>;
     fetchOpenOrdersWs(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     createOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, params?: {}): Promise<Order>;
-    editOrderWs(id: string, symbol: any, type: any, side: any, amount?: any, price?: any, params?: {}): Promise<Order>;
+    editOrderWs(id: string, symbol: string, type: OrderType, side: OrderSide, amount?: number, price?: number, params?: {}): Promise<Order>;
     cancelOrderWs(id: string, symbol?: string, params?: {}): Promise<Order>;
-    cancelOrdersWs(ids: any, symbol?: string, params?: {}): Promise<Order[]>;
+    cancelOrdersWs(ids: string[], symbol?: string, params?: {}): Promise<Order[]>;
     resolveData(client: Client, message: any): void;
     handleConnected(client: Client, message: any): any;
     handleErrorMessage(client: Client, message: any): void;

package/js/src/pro/coinbase.d.ts

@@ -3,12 +3,12 @@ import { Strings, Tickers, Ticker, Int, Trade, OrderBook, Order } from '../base/
 export default class coinbase extends coinbaseRest {
     describe(): any;
     subscribe(name: any, symbol?: any, params?: {}): Promise<any>;
-    watchTicker(symbol: any, params?: {}): Promise<Ticker>;
+    watchTicker(symbol: string, params?: {}): Promise<Ticker>;
     watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     handleTickers(client: any, message: any): any;
     parseWsTicker(ticker: any, market?: any): Ticker;
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
-    watchOrders(symbol?: any, since?: any, limit?: any, params?: {}): Promise<Order[]>;
+    watchOrders(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     handleTrade(client: any, message: any): any;
     handleOrder(client: any, message: any): any;

package/js/src/pro/coinex.d.ts

@@ -16,7 +16,7 @@ export default class coinex extends coinexRest {
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
-    fetchOHLCVWs(symbol: any, timeframe?: string, since?: any, limit?: any, params?: {}): Promise<OHLCV[]>;
+    fetchOHLCVWs(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     handleDelta(bookside: any, delta: any): void;
     handleDeltas(bookside: any, deltas: any): void;
     handleOrderBook(client: Client, message: any): void;

package/js/src/pro/lbank.d.ts

@@ -8,7 +8,7 @@ export default class lbank extends lbankRest {
     watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     handleOHLCV(client: any, message: any): void;
     fetchTickerWs(symbol: any, params?: {}): Promise<Ticker>;
-    watchTicker(symbol: any, params?: {}): Promise<Ticker>;
+    watchTicker(symbol: string, params?: {}): Promise<Ticker>;
     handleTicker(client: any, message: any): void;
     parseWsTicker(ticker: any, market?: any): Ticker;
     fetchTradesWs(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;

package/js/src/pro/mexc.js

@@ -472,7 +472,7 @@ export default class mexc extends mexcRest {
         }
         try {
             this.handleDelta(storedOrderBook, data);
-            const timestamp = this.safeInteger(message, 't');
+            const timestamp = this.safeInteger2(message, 't', 'ts');
             storedOrderBook['timestamp'] = timestamp;
             storedOrderBook['datetime'] = this.iso8601(timestamp);
         }

package/js/src/probit.d.ts

@@ -44,7 +44,7 @@ export default class probit extends Exchange {
         network: string;
         info: any;
     }>;
-    fetchDepositAddresses(codes?: any, params?: {}): Promise<{}>;
+    fetchDepositAddresses(codes?: string[], params?: {}): Promise<{}>;
     withdraw(code: string, amount: number, address: any, tag?: any, params?: {}): Promise<Transaction>;
     fetchDeposits(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
     fetchWithdrawals(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;

package/js/src/timex.d.ts

@@ -20,7 +20,7 @@ export default class timex extends Exchange {
     parseBalance(response: any): Balances;
     fetchBalance(params?: {}): Promise<Balances>;
     createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, params?: {}): Promise<Order>;
-    editOrder(id: string, symbol: any, type: any, side: any, amount?: any, price?: any, params?: {}): Promise<Order>;
+    editOrder(id: string, symbol: string, type: OrderType, side: OrderSide, amount?: number, price?: number, params?: {}): Promise<Order>;
     cancelOrder(id: string, symbol?: Str, params?: {}): Promise<any>;
     cancelOrders(ids: any, symbol?: Str, params?: {}): Promise<any>;
     fetchOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;

package/js/src/upbit.d.ts

@@ -72,7 +72,7 @@ export default class upbit extends Exchange {
     fetchClosedOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchCanceledOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
-    fetchDepositAddresses(codes?: any, params?: {}): Promise<{}>;
+    fetchDepositAddresses(codes?: string[], params?: {}): Promise<{}>;
     parseDepositAddress(depositAddress: any, currency?: Currency): {
         currency: string;
         address: string;

package/js/src/wavesexchange.js

@@ -314,7 +314,7 @@ export default class wavesexchange extends Exchange {
                 },
             },
             'currencies': {
-                'WX': this.safeCurrencyStructure({ 'id': 'EMAMLxDnv3xiz8RXg8Btj33jcEw3wLczL3JKYYmuubpc', 'numericId': undefined, 'code': 'WX', 'precision': this.parseNumber('8') }),
+                'WX': this.safeCurrencyStructure({ 'id': 'EMAMLxDnv3xiz8RXg8Btj33jcEw3wLczL3JKYYmuubpc', 'numericId': undefined, 'code': 'WX', 'precision': this.parseToInt('8') }),
             },
             'precisionMode': DECIMAL_PLACES,
             'options': {

package/js/src/whitebit.d.ts

@@ -9,7 +9,7 @@ export default class whitebit extends Exchange {
     fetchMarkets(params?: {}): Promise<import("./base/types.js").MarketInterface[]>;
     parseMarket(market: any): Market;
     fetchCurrencies(params?: {}): Promise<{}>;
-    fetchTransactionFees(codes?: any, params?: {}): Promise<{
+    fetchTransactionFees(codes?: string[], params?: {}): Promise<{
         withdraw: {};
         deposit: {};
         info: any;
@@ -51,7 +51,7 @@ export default class whitebit extends Exchange {
         info: any;
     }>;
     setLeverage(leverage: Int, symbol?: Str, params?: {}): Promise<any>;
-    transfer(code: string, amount: number, fromAccount: any, toAccount: any, params?: {}): Promise<TransferEntry>;
+    transfer(code: string, amount: number, fromAccount: string, toAccount: string, params?: {}): Promise<TransferEntry>;
     parseTransfer(transfer: any, currency?: Currency): {
         info: any;
         id: any;

package/js/src/woo.d.ts

@@ -13,11 +13,11 @@ export default class woo extends Exchange {
     parseTokenAndFeeTemp(item: any, feeTokenKey: any, feeAmountKey: any): any;
     fetchTradingFees(params?: {}): Promise<{}>;
     fetchCurrencies(params?: {}): Promise<{}>;
-    createMarketBuyOrderWithCost(symbol: string, cost: any, params?: {}): Promise<Order>;
+    createMarketBuyOrderWithCost(symbol: string, cost: number, params?: {}): Promise<Order>;
     createTrailingAmountOrder(symbol: string, type: OrderType, side: OrderSide, amount: any, price?: any, trailingAmount?: any, trailingTriggerPrice?: any, params?: {}): Promise<Order>;
     createTrailingPercentOrder(symbol: string, type: OrderType, side: OrderSide, amount: any, price?: any, trailingPercent?: any, trailingTriggerPrice?: any, params?: {}): Promise<Order>;
     createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, params?: {}): Promise<Order>;
-    editOrder(id: string, symbol: any, type: any, side: any, amount?: any, price?: any, params?: {}): Promise<Order>;
+    editOrder(id: string, symbol: string, type: OrderType, side: OrderSide, amount?: number, price?: number, params?: {}): Promise<Order>;
     cancelOrder(id: string, symbol?: Str, params?: {}): Promise<any>;
     cancelAllOrders(symbol?: Str, params?: {}): Promise<any>;
     fetchOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
@@ -73,7 +73,7 @@ export default class woo extends Exchange {
     fetchDepositsWithdrawals(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
     parseTransaction(transaction: any, currency?: Currency): Transaction;
     parseTransactionStatus(status: any): string;
-    transfer(code: string, amount: number, fromAccount: any, toAccount: any, params?: {}): Promise<TransferEntry>;
+    transfer(code: string, amount: number, fromAccount: string, toAccount: string, params?: {}): Promise<TransferEntry>;
     fetchTransfers(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
     parseTransfer(transfer: any, currency?: Currency): {
         id: string;

package/js/src/woo.js

@@ -1068,7 +1068,7 @@ export default class woo extends Exchange {
         if (stopPrice !== undefined) {
             request['triggerPrice'] = this.priceToPrecision(symbol, stopPrice);
         }
-        const trailingTriggerPrice = this.safeString2(params, 'trailingTriggerPrice', 'activatedPrice', price);
+        const trailingTriggerPrice = this.safeString2(params, 'trailingTriggerPrice', 'activatedPrice', this.numberToString(price));
         const trailingAmount = this.safeString2(params, 'trailingAmount', 'callbackValue');
         const trailingPercent = this.safeString2(params, 'trailingPercent', 'callbackRate');
         const isTrailingAmountOrder = trailingAmount !== undefined;

package/js/src/zonda.d.ts

@@ -15,7 +15,7 @@ export default class zonda extends Exchange {
     fetchBalance(params?: {}): Promise<Balances>;
     fetchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     parseTicker(ticker: any, market?: Market): Ticker;
-    fetchTicker(symbol: any, params?: {}): Promise<Ticker>;
+    fetchTicker(symbol: string, params?: {}): Promise<Ticker>;
     fetchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     fetchLedger(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
     parseLedgerEntry(item: any, currency?: Currency): {
@@ -57,8 +57,8 @@ export default class zonda extends Exchange {
         network: any;
         info: any;
     }>;
-    fetchDepositAddresses(codes?: any, params?: {}): Promise<{}>;
-    transfer(code: string, amount: number, fromAccount: any, toAccount: any, params?: {}): Promise<TransferEntry>;
+    fetchDepositAddresses(codes?: string[], params?: {}): Promise<{}>;
+    transfer(code: string, amount: number, fromAccount: string, toAccount: string, params?: {}): Promise<TransferEntry>;
     parseTransfer(transfer: any, currency?: Currency): {
         info: any;
         id: any;