ccxt 4.2.38 → 4.2.40

package/dist/cjs/src/pro/bitmart.js

@@ -24,8 +24,10 @@ class bitmart extends bitmart$1 {
                 'watchTicker': true,
                 'watchTickers': true,
                 'watchOrderBook': true,
+                'watchOrderBookForSymbols': true,
                 'watchOrders': true,
                 'watchTrades': true,
+                'watchTradesForSymbols': true,
                 'watchOHLCV': true,
                 'watchPosition': 'emulated',
                 'watchPositions': true,
@@ -50,8 +52,15 @@ class bitmart extends bitmart$1 {
                     '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,
@@ -98,6 +107,24 @@ class bitmart extends bitmart$1 {
         }
         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
@@ -245,17 +272,43 @@ class bitmart extends bitmart$1 {
          * @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 errors.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
@@ -793,16 +846,15 @@ class bitmart extends bitmart$1 {
         //        ]
         //    }
         //
-        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) {
@@ -811,10 +863,7 @@ class bitmart extends bitmart$1 {
             }
             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) {
@@ -1156,8 +1205,8 @@ class bitmart extends bitmart$1 {
         //         "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');
@@ -1171,6 +1220,7 @@ class bitmart extends bitmart$1 {
     handleOrderBook(client, message) {
         //
         // spot depth-all
+        //
         //    {
         //        "data": [
         //            {
@@ -1190,33 +1240,31 @@ class bitmart extends bitmart$1 {
         //        ],
         //        "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":{
@@ -1237,50 +1285,69 @@ class bitmart extends bitmart$1 {
         //        }
         //    }
         //
-        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;
@@ -1309,10 +1376,36 @@ class bitmart extends bitmart$1 {
             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/dist/cjs/src/pro/bybit.js

@@ -184,7 +184,7 @@ class bybit extends bybit$1 {
         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');
@@ -209,7 +209,7 @@ class bybit extends bybit$1 {
         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');
@@ -376,7 +376,7 @@ class bybit extends bybit$1 {
         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);
@@ -494,7 +494,7 @@ class bybit extends bybit$1 {
             throw new errors.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) {
@@ -626,7 +626,7 @@ class bybit extends bybit$1 {
             throw new errors.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/dist/cjs/src/pro/mexc.js

@@ -469,7 +469,7 @@ class mexc extends mexc$1 {
         }
         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/dist/cjs/src/wavesexchange.js

@@ -311,7 +311,7 @@ class wavesexchange extends wavesexchange$1 {
                 },
             },
             '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': number.DECIMAL_PLACES,
             'options': {

package/dist/cjs/src/woo.js

@@ -1065,7 +1065,7 @@ class woo extends woo$1 {
         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/ccxt.d.ts

@@ -4,7 +4,7 @@ import * as functions from './src/base/functions.js';
 import * as errors from './src/base/errors.js';
 import type { Market, Trade, Fee, Ticker, OrderBook, Order, Transaction, Tickers, Currency, Balance, DepositAddress, WithdrawalResponse, DepositAddressResponse, OHLCV, Balances, PartialBalances, Dictionary, MinMax, Position, FundingRateHistory, Liquidation, FundingHistory, MarginMode, Greeks } from './src/base/types.js';
 import { BaseError, ExchangeError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, MarginModeAlreadySet, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, NotSupported, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout, AuthenticationError, AddressPending, NoChange } from './src/base/errors.js';
-declare const version = "4.2.37";
+declare const version = "4.2.39";
 import ace from './src/ace.js';
 import alpaca from './src/alpaca.js';
 import ascendex from './src/ascendex.js';

package/js/ccxt.js

@@ -38,7 +38,7 @@ import * as errors from './src/base/errors.js';
 import { BaseError, ExchangeError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, MarginModeAlreadySet, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, NotSupported, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout, AuthenticationError, AddressPending, NoChange } from './src/base/errors.js';
 //-----------------------------------------------------------------------------
 // this is updated by vss.js when building
-const version = '4.2.38';
+const version = '4.2.40';
 Exchange.ccxtVersion = version;
 //-----------------------------------------------------------------------------
 import ace from './src/ace.js';

package/js/src/abstract/bingx.d.ts

@@ -15,6 +15,7 @@ interface Exchange {
     spotV1PrivatePostTradeOrder(params?: {}): Promise<implicitReturnType>;
     spotV1PrivatePostTradeCancel(params?: {}): Promise<implicitReturnType>;
     spotV1PrivatePostTradeBatchOrders(params?: {}): Promise<implicitReturnType>;
+    spotV1PrivatePostTradeOrderCancelReplace(params?: {}): Promise<implicitReturnType>;
     spotV1PrivatePostTradeCancelOrders(params?: {}): Promise<implicitReturnType>;
     spotV1PrivatePostTradeCancelOpenOrders(params?: {}): Promise<implicitReturnType>;
     spotV3PrivateGetGetAssetTransfer(params?: {}): Promise<implicitReturnType>;
@@ -22,8 +23,11 @@ interface Exchange {
     spotV3PrivateGetCapitalDepositHisrec(params?: {}): Promise<implicitReturnType>;
     spotV3PrivateGetCapitalWithdrawHistory(params?: {}): Promise<implicitReturnType>;
     spotV3PrivatePostPostAssetTransfer(params?: {}): Promise<implicitReturnType>;
+    swapV1PublicGetTickerPrice(params?: {}): Promise<implicitReturnType>;
     swapV1PrivateGetPositionSideDual(params?: {}): Promise<implicitReturnType>;
     swapV1PrivateGetMarketMarkPriceKlines(params?: {}): Promise<implicitReturnType>;
+    swapV1PrivateGetTradeBatchCancelReplace(params?: {}): Promise<implicitReturnType>;
+    swapV1PrivatePostTradeCancelReplace(params?: {}): Promise<implicitReturnType>;
     swapV1PrivatePostPositionSideDual(params?: {}): Promise<implicitReturnType>;
     swapV2PublicGetServerTime(params?: {}): Promise<implicitReturnType>;
     swapV2PublicGetQuoteContracts(params?: {}): Promise<implicitReturnType>;

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

@@ -72,6 +72,7 @@ interface Exchange {
     v3PrivatePostBrokerageOrdersBatchCancel(params?: {}): Promise<implicitReturnType>;
     v3PrivatePostBrokerageOrdersEdit(params?: {}): Promise<implicitReturnType>;
     v3PrivatePostBrokerageOrdersEditPreview(params?: {}): Promise<implicitReturnType>;
+    v3PrivatePostBrokerageOrdersPreview(params?: {}): Promise<implicitReturnType>;
     v3PrivatePostBrokeragePortfolios(params?: {}): Promise<implicitReturnType>;
     v3PrivatePostBrokeragePortfoliosMoveFunds(params?: {}): Promise<implicitReturnType>;
     v3PrivatePostBrokerageConvertQuote(params?: {}): Promise<implicitReturnType>;

package/js/src/abstract/coinbasepro.d.ts

@@ -46,6 +46,7 @@ interface Exchange {
     privateGetUsersSelfTrailingVolume(params?: {}): Promise<implicitReturnType>;
     privateGetWithdrawalsFeeEstimate(params?: {}): Promise<implicitReturnType>;
     privateGetConversionsConversionId(params?: {}): Promise<implicitReturnType>;
+    privateGetConversionsFees(params?: {}): Promise<implicitReturnType>;
     privatePostConversions(params?: {}): Promise<implicitReturnType>;
     privatePostDepositsCoinbaseAccount(params?: {}): Promise<implicitReturnType>;
     privatePostDepositsPaymentMethod(params?: {}): Promise<implicitReturnType>;

package/js/src/abstract/okx.d.ts

@@ -98,6 +98,7 @@ interface Exchange {
     privateGetTradeEasyConvertHistory(params?: {}): Promise<implicitReturnType>;
     privateGetTradeOneClickRepayCurrencyList(params?: {}): Promise<implicitReturnType>;
     privateGetTradeOneClickRepayHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetTradeAccountRateLimit(params?: {}): Promise<implicitReturnType>;
     privateGetAssetCurrencies(params?: {}): Promise<implicitReturnType>;
     privateGetAssetBalances(params?: {}): Promise<implicitReturnType>;
     privateGetAssetNonTradableAssets(params?: {}): Promise<implicitReturnType>;

package/js/src/ascendex.d.ts

@@ -87,7 +87,7 @@ export default class ascendex extends Exchange {
     reduceMargin(symbol: string, amount: any, params?: {}): Promise<any>;
     addMargin(symbol: string, amount: any, params?: {}): Promise<any>;
     setLeverage(leverage: Int, symbol?: Str, params?: {}): Promise<any>;
-    setMarginMode(marginMode: any, symbol?: Str, params?: {}): Promise<any>;
+    setMarginMode(marginMode: string, symbol?: Str, params?: {}): Promise<any>;
     fetchLeverageTiers(symbols?: Strings, params?: {}): Promise<{}>;
     parseMarketLeverageTiers(info: any, market?: Market): any[];
     parseDepositWithdrawFee(fee: any, currency?: Currency): {
@@ -103,7 +103,7 @@ export default class ascendex extends Exchange {
         networks: {};
     };
     fetchDepositWithdrawFees(codes?: Strings, 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/ascendex.js

@@ -277,11 +277,14 @@ export default class ascendex extends Exchange {
                     'fillResponseFromRequest': true,
                 },
                 'networks': {
-                    'BSC': 'BEP20 (BSC)',
+                    'BSC': 'BEP20 ' + '(BSC)',
                     'ARB': 'arbitrum',
                     'SOL': 'Solana',
                     'AVAX': 'avalanche C chain',
                     'OMNI': 'Omni',
+                    'TRC': 'TRC20',
+                    'TRX': 'TRC20',
+                    'ERC': 'ERC20',
                 },
                 'networksById': {
                     'BEP20 (BSC)': 'BSC',
@@ -289,6 +292,16 @@ export default class ascendex extends Exchange {
                     'Solana': 'SOL',
                     'avalanche C chain': 'AVAX',
                     'Omni': 'OMNI',
+                    'TRC20': 'TRC20',
+                    'ERC20': 'ERC20',
+                    'GO20': 'GO20',
+                    'BEP2': 'BEP2',
+                    'Bitcoin': 'BTC',
+                    'Bitcoin ABC': 'BCH',
+                    'Litecoin': 'LTC',
+                    'Matic Network': 'MATIC',
+                    'xDai': 'STAKE',
+                    'Akash': 'AKT',
                 },
             },
             'exceptions': {
@@ -2378,8 +2391,8 @@ export default class ascendex extends Exchange {
         const tag = this.safeString(depositAddress, tagId);
         this.checkAddress(address);
         const code = (currency === undefined) ? undefined : currency['code'];
-        const chainName = this.safeString(depositAddress, 'chainName');
-        const network = this.safeNetwork(chainName);
+        const chainName = this.safeString(depositAddress, 'blockchain');
+        const network = this.networkIdToCode(chainName, code);
         return {
             'currency': code,
             'address': address,
@@ -2389,20 +2402,7 @@ export default class ascendex extends Exchange {
         };
     }
     safeNetwork(networkId) {
-        const networksById = {
-            'TRC20': 'TRC20',
-            'ERC20': 'ERC20',
-            'GO20': 'GO20',
-            'BEP2': 'BEP2',
-            'BEP20 (BSC)': 'BEP20',
-            'Bitcoin': 'BTC',
-            'Bitcoin ABC': 'BCH',
-            'Litecoin': 'LTC',
-            'Matic Network': 'MATIC',
-            'Solana': 'SOL',
-            'xDai': 'STAKE',
-            'Akash': 'AKT',
-        };
+        const networksById = this.safeDict(this.options, 'networksById');
         return this.safeString(networksById, networkId, networkId);
     }
     async fetchDepositAddress(code, params = {}) {
@@ -2410,16 +2410,20 @@ export default class ascendex extends Exchange {
          * @method
          * @name ascendex#fetchDepositAddress
          * @description fetch the deposit address for a currency associated with this account
+         * @see https://ascendex.github.io/ascendex-pro-api/#query-deposit-addresses
          * @param {string} code unified currency code
          * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {string} [params.network] unified network code for deposit chain
          * @returns {object} an [address structure]{@link https://docs.ccxt.com/#/?id=address-structure}
          */
         await this.loadMarkets();
         const currency = this.currency(code);
-        const chainName = this.safeString(params, 'chainName');
-        params = this.omit(params, 'chainName');
+        const networkCode = this.safeString2(params, 'network', 'chainName');
+        const networkId = this.networkCodeToId(networkCode);
+        params = this.omit(params, ['chainName']);
         const request = {
             'asset': currency['id'],
+            'blockchain': networkId,
         };
         const response = await this.v1PrivateGetWalletDepositAddress(this.extend(request, params));
         //
@@ -2455,22 +2459,22 @@ export default class ascendex extends Exchange {
         //         }
         //     }
         //
-        const data = this.safeValue(response, 'data', {});
-        const addresses = this.safeValue(data, 'address', []);
+        const data = this.safeDict(response, 'data', {});
+        const addresses = this.safeList(data, 'address', []);
         const numAddresses = addresses.length;
         let address = undefined;
         if (numAddresses > 1) {
             const addressesByChainName = this.indexBy(addresses, 'chainName');
-            if (chainName === undefined) {
+            if (networkId === undefined) {
                 const chainNames = Object.keys(addressesByChainName);
                 const chains = chainNames.join(', ');
                 throw new ArgumentsRequired(this.id + ' fetchDepositAddress() returned more than one address, a chainName parameter is required, one of ' + chains);
             }
-            address = this.safeValue(addressesByChainName, chainName, {});
+            address = this.safeDict(addressesByChainName, networkId, {});
         }
         else {
             // first address
-            address = this.safeValue(addresses, 0, {});
+            address = this.safeDict(addresses, 0, {});
         }
         const result = this.parseDepositAddress(address, currency);
         return this.extend(result, {