ccxt 4.2.39 → 4.2.41

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

@@ -27,6 +27,7 @@ class bitmart extends bitmart$1 {
                 'watchOrderBookForSymbols': true,
                 'watchOrders': true,
                 'watchTrades': true,
+                'watchTradesForSymbols': true,
                 'watchOHLCV': true,
                 'watchPosition': 'emulated',
                 'watchPositions': true,
@@ -271,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
@@ -819,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) {
@@ -837,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) {
@@ -1373,15 +1396,10 @@ class bitmart extends bitmart$1 {
          * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
          */
         await this.loadMarkets();
-        symbols = this.marketSymbols(symbols, undefined, false, true);
-        if (symbols.length > 20) {
-            throw new errors.NotSupported(this.id + ' watchOrderBookForSymbols() accepts a maximum of 20 symbols in one request');
-        }
-        const market = this.market(symbols[0]);
+        let type = undefined;
+        [symbols, type, params] = this.getParamsForMultipleSub('watchOrderBookForSymbols', symbols, limit, params);
         let channel = undefined;
         [channel, params] = this.handleOptionAndParams(params, 'watchOrderBookForSymbols', 'depth', 'depth/increase100');
-        let type = 'spot';
-        [type, params] = this.handleMarketTypeAndParams('watchOrderBookForSymbols', market, params);
         if (type === 'swap' && channel === 'depth/increase100') {
             channel = 'depth50';
         }

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/cex.js

@@ -185,7 +185,7 @@ class cex extends cex$1 {
             trade = trade.split(':');
         }
         const side = this.safeString(trade, 0);
-        const timestamp = this.safeNumber(trade, 1);
+        const timestamp = this.safeInteger(trade, 1);
         const amount = this.safeString(trade, 2);
         const price = this.safeString(trade, 3);
         const id = this.safeString(trade, 4);

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

@@ -641,7 +641,7 @@ class gemini extends gemini$1 {
         //         "socket_sequence": 139
         //     }
         //
-        const timestamp = this.safeNumber(order, 'timestampms');
+        const timestamp = this.safeInteger(order, 'timestampms');
         const status = this.safeString(order, 'type');
         const marketId = this.safeString(order, 'symbol');
         const typeId = this.safeString(order, 'order_type');

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.38";
+declare const version = "4.2.40";
 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.39';
+const version = '4.2.41';
 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/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/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, {

package/js/src/base/Exchange.d.ts

@@ -721,11 +721,11 @@ export default class Exchange {
     networkCodeToId(networkCode: any, currencyCode?: any): string;
     networkIdToCode(networkId: any, currencyCode?: any): string;
     handleNetworkCodeAndParams(params: any): any[];
-    defaultNetworkCode(currencyCode: any): any;
+    defaultNetworkCode(currencyCode: string): any;
     selectNetworkCodeFromUnifiedNetworks(currencyCode: any, networkCode: any, indexedNetworkEntries: any): any;
     selectNetworkIdFromRawNetworks(currencyCode: any, networkCode: any, indexedNetworkEntries: any): any;
     selectNetworkKeyFromNetworks(currencyCode: any, networkCode: any, indexedNetworkEntries: any, isIndexedByUnifiedNetworkCode?: boolean): any;
-    safeNumber2(dictionary: any, key1: any, key2: any, d?: any): number;
+    safeNumber2(dictionary: object, key1: IndexType, key2: IndexType, d?: any): number;
     parseOrderBook(orderbook: object, symbol: string, timestamp?: Int, bidsKey?: string, asksKey?: string, priceKey?: IndexType, amountKey?: IndexType, countOrIdKey?: IndexType): OrderBook;
     parseOHLCVs(ohlcvs: object[], market?: any, timeframe?: string, since?: Int, limit?: Int): OHLCV[];
     parseLeverageTiers(response: any, symbols?: string[], marketIdKey?: any): {};
@@ -788,12 +788,12 @@ export default class Exchange {
     getSupportedMapping(key: any, mapping?: {}): any;
     fetchCrossBorrowRate(code: string, params?: {}): Promise<{}>;
     fetchIsolatedBorrowRate(symbol: string, params?: {}): Promise<{}>;
-    handleOptionAndParams(params: any, methodName: any, optionName: any, defaultValue?: any): any[];
-    handleOptionAndParams2(params: any, methodName: any, methodName2: any, optionName: any, defaultValue?: any): any[];
-    handleOption(methodName: any, optionName: any, defaultValue?: any): any;
+    handleOptionAndParams(params: object, methodName: string, optionName: string, defaultValue?: any): any[];
+    handleOptionAndParams2(params: object, methodName: string, methodName2: string, optionName: string, defaultValue?: any): any[];
+    handleOption(methodName: string, optionName: string, defaultValue?: any): any;
     handleMarketTypeAndParams(methodName: string, market?: Market, params?: {}): any;
-    handleSubTypeAndParams(methodName: any, market?: any, params?: {}, defaultValue?: any): any[];
-    handleMarginModeAndParams(methodName: any, params?: {}, defaultValue?: any): any[];
+    handleSubTypeAndParams(methodName: string, market?: any, params?: {}, defaultValue?: any): any[];
+    handleMarginModeAndParams(methodName: string, params?: {}, defaultValue?: any): any[];
     throwExactlyMatchedException(exact: any, string: any, message: any): void;
     throwBroadlyMatchedException(broad: any, string: any, message: any): void;
     findBroadlyMatchedKey(broad: any, string: any): string;
@@ -855,7 +855,7 @@ export default class Exchange {
     fetchDepositAddress(code: string, params?: {}): Promise<any>;
     account(): Account;
     commonCurrencyCode(currency: string): string;
-    currency(code: any): any;
+    currency(code: string): any;
     market(symbol: string): MarketInterface;
     createExpiredOptionMarket(symbol: string): MarketInterface;
     handleWithdrawTagAndParams(tag: any, params: any): any;

package/js/src/base/Exchange.js

@@ -3192,14 +3192,14 @@ export default class Exchange {
     }
     defaultNetworkCode(currencyCode) {
         let defaultNetworkCode = undefined;
-        const defaultNetworks = this.safeValue(this.options, 'defaultNetworks', {});
+        const defaultNetworks = this.safeDict(this.options, 'defaultNetworks', {});
         if (currencyCode in defaultNetworks) {
             // if currency had set its network in "defaultNetworks", use it
             defaultNetworkCode = defaultNetworks[currencyCode];
         }
         else {
             // otherwise, try to use the global-scope 'defaultNetwork' value (even if that network is not supported by currency, it doesn't make any problem, this will be just used "at first" if currency supports this network at all)
-            const defaultNetwork = this.safeValue(this.options, 'defaultNetwork');
+            const defaultNetwork = this.safeDict(this.options, 'defaultNetwork');
             if (defaultNetwork !== undefined) {
                 defaultNetworkCode = defaultNetwork;
             }
@@ -3704,14 +3704,14 @@ export default class Exchange {
         throw new NotSupported(this.id + ' fetchStatus() is not supported yet');
     }
     async fetchFundingFee(code, params = {}) {
-        const warnOnFetchFundingFee = this.safeValue(this.options, 'warnOnFetchFundingFee', true);
+        const warnOnFetchFundingFee = this.safeBool(this.options, 'warnOnFetchFundingFee', true);
         if (warnOnFetchFundingFee) {
             throw new NotSupported(this.id + ' fetchFundingFee() method is deprecated, it will be removed in July 2022, please, use fetchTransactionFee() or set exchange.options["warnOnFetchFundingFee"] = false to suppress this warning');
         }
         return await this.fetchTransactionFee(code, params);
     }
     async fetchFundingFees(codes = undefined, params = {}) {
-        const warnOnFetchFundingFees = this.safeValue(this.options, 'warnOnFetchFundingFees', true);
+        const warnOnFetchFundingFees = this.safeBool(this.options, 'warnOnFetchFundingFees', true);
         if (warnOnFetchFundingFees) {
             throw new NotSupported(this.id + ' fetchFundingFees() method is deprecated, it will be removed in July 2022. Please, use fetchTransactionFees() or set exchange.options["warnOnFetchFundingFees"] = false to suppress this warning');
         }
@@ -3762,7 +3762,7 @@ export default class Exchange {
             throw new NotSupported(this.id + ' fetchIsolatedBorrowRate() is not supported yet');
         }
         const borrowRates = await this.fetchIsolatedBorrowRates(params);
-        const rate = this.safeValue(borrowRates, symbol);
+        const rate = this.safeDict(borrowRates, symbol);
         if (rate === undefined) {
             throw new ExchangeError(this.id + ' fetchIsolatedBorrowRate() could not find the borrow rate for market symbol ' + symbol);
         }
@@ -3823,7 +3823,7 @@ export default class Exchange {
     }
     handleMarketTypeAndParams(methodName, market = undefined, params = {}) {
         const defaultType = this.safeString2(this.options, 'defaultType', 'type', 'spot');
-        const methodOptions = this.safeValue(this.options, methodName);
+        const methodOptions = this.safeDict(this.options, methodName);
         let methodType = defaultType;
         if (methodOptions !== undefined) {
             if (typeof methodOptions === 'string') {
@@ -3859,7 +3859,7 @@ export default class Exchange {
             }
             // if it was not defined in market object
             if (subType === undefined) {
-                const values = this.handleOptionAndParams(undefined, methodName, 'subType', defaultValue); // no need to re-test params here
+                const values = this.handleOptionAndParams({}, methodName, 'subType', defaultValue); // no need to re-test params here
                 subType = values[0];
             }
         }
@@ -3915,7 +3915,7 @@ export default class Exchange {
             const market = this.market(symbol);
             symbol = market['symbol'];
             const tickers = await this.fetchTickers([symbol], params);
-            const ticker = this.safeValue(tickers, symbol);
+            const ticker = this.safeDict(tickers, symbol);
             if (ticker === undefined) {
                 throw new NullResponse(this.id + ' fetchTickers() could not find a ticker for ' + symbol);
             }
@@ -3952,7 +3952,7 @@ export default class Exchange {
         return order['status'];
     }
     async fetchUnifiedOrder(order, params = {}) {
-        return await this.fetchOrder(this.safeValue(order, 'id'), this.safeValue(order, 'symbol'), params);
+        return await this.fetchOrder(this.safeString(order, 'id'), this.safeString(order, 'symbol'), params);
     }
     async createOrder(symbol, type, side, amount, price = undefined, params = {}) {
         throw new NotSupported(this.id + ' createOrder() is not supported yet');
@@ -4222,7 +4222,7 @@ export default class Exchange {
         throw new NotSupported(this.id + ' cancelAllOrdersWs() is not supported yet');
     }
     async cancelUnifiedOrder(order, params = {}) {
-        return this.cancelOrder(this.safeValue(order, 'id'), this.safeValue(order, 'symbol'), params);
+        return this.cancelOrder(this.safeString(order, 'id'), this.safeString(order, 'symbol'), params);
     }
     async fetchOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         if (this.has['fetchOpenOrders'] && this.has['fetchClosedOrders']) {
@@ -4714,7 +4714,7 @@ export default class Exchange {
         return result;
     }
     isTriggerOrder(params) {
-        const isTrigger = this.safeValue2(params, 'trigger', 'stop');
+        const isTrigger = this.safeBool2(params, 'trigger', 'stop');
         if (isTrigger) {
             params = this.omit(params, ['trigger', 'stop']);
         }
@@ -4730,7 +4730,7 @@ export default class Exchange {
          * @returns {boolean} true if a post only order, false otherwise
          */
         const timeInForce = this.safeStringUpper(params, 'timeInForce');
-        let postOnly = this.safeValue2(params, 'postOnly', 'post_only', false);
+        let postOnly = this.safeBool2(params, 'postOnly', 'post_only', false);
         // we assume timeInForce is uppercase from safeStringUpper (params, 'timeInForce')
         const ioc = timeInForce === 'IOC';
         const fok = timeInForce === 'FOK';
@@ -4924,7 +4924,7 @@ export default class Exchange {
          * @param {string} account key for account name in this.options['accountsByType']
          * @returns the exchange specific account name or the isolated margin id for transfers
          */
-        const accountsByType = this.safeValue(this.options, 'accountsByType', {});
+        const accountsByType = this.safeDict(this.options, 'accountsByType', {});
         const lowercaseAccount = account.toLowerCase();
         if (lowercaseAccount in accountsByType) {
             return accountsByType[lowercaseAccount];
@@ -5401,7 +5401,7 @@ export default class Exchange {
         return input;
     }
     handleUntilOption(key, request, params, multiplier = 1) {
-        const until = this.safeValue2(params, 'until', 'till');
+        const until = this.safeInteger2(params, 'until', 'till');
         if (until !== undefined) {
             request[key] = this.parseToInt(until * multiplier);
             params = this.omit(params, ['until', 'till']);

package/js/src/binance.d.ts

@@ -297,7 +297,7 @@ export default class binance extends Exchange {
         body: any;
         headers: any;
     };
-    getExceptionsByUrl(url: any, exactOrBroad: any): any;
+    getExceptionsByUrl(url: any, exactOrBroad: any): import("./base/types.js").Dictionary<any>;
     handleErrors(code: any, reason: any, url: any, method: any, headers: any, body: any, response: any, requestHeaders: any, requestBody: any): any;
     calculateRateLimiterCost(api: any, method: any, path: any, params: any, config?: {}): any;
     request(path: any, api?: string, method?: string, params?: {}, headers?: any, body?: any, config?: {}): Promise<any>;