ccxt 4.3.15 → 4.3.17

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

@@ -450,10 +450,12 @@ class okx extends okx$1 {
         /**
          * @method
          * @name okx#watchOrderBook
+         * @see https://www.okx.com/docs-v5/en/#order-book-trading-market-data-ws-order-book-channel
          * @description watches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
          * @param {string} symbol unified symbol of the market to fetch the order book for
          * @param {int} [limit] the maximum amount of order book entries to return
          * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {string} [params.depth] okx order book depth, can be books, books5, books-l2-tbt, books50-l2-tbt, bbo-tbt
          * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
          */
         //
@@ -485,16 +487,18 @@ class okx extends okx$1 {
         /**
          * @method
          * @name okx#watchOrderBookForSymbols
+         * @see https://www.okx.com/docs-v5/en/#order-book-trading-market-data-ws-order-book-channel
          * @description watches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
          * @param {string[]} symbols unified array of symbols
          * @param {int} [limit] 1,5, 400, 50 (l2-tbt, vip4+) or 40000 (vip5+) the maximum amount of order book entries to return
          * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {string} [params.depth] okx order book depth, can be books, books5, books-l2-tbt, books50-l2-tbt, bbo-tbt
          * @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);
-        const options = this.safeValue(this.options, 'watchOrderBook', {});
-        let depth = this.safeString(options, 'depth', 'books');
+        let depth = undefined;
+        [depth, params] = this.handleOptionAndParams(params, 'watchOrderBook', 'depth', 'books');
         if (limit !== undefined) {
             if (limit === 1) {
                 depth = 'bbo-tbt';
@@ -502,17 +506,17 @@ class okx extends okx$1 {
             else if (limit > 1 && limit <= 5) {
                 depth = 'books5';
             }
-            else if (limit === 400) {
-                depth = 'books';
-            }
             else if (limit === 50) {
                 depth = 'books50-l2-tbt'; // Make sure you have VIP4 and above
             }
-            else if (limit === 4000) {
-                depth = 'books-l2-tbt'; // Make sure you have VIP5 and above
+            else if (limit === 400) {
+                depth = 'books';
             }
         }
         if ((depth === 'books-l2-tbt') || (depth === 'books50-l2-tbt')) {
+            if (!this.checkRequiredCredentials(false)) {
+                throw new errors.AuthenticationError(this.id + ' watchOrderBook/watchOrderBookForSymbols requires authentication for this depth. Add credentials or change the depth option to books or books5');
+            }
             await this.authenticate({ 'access': 'public' });
         }
         const topics = [];
@@ -576,6 +580,8 @@ class okx extends okx$1 {
         const storedBids = orderbook['bids'];
         this.handleDeltas(storedAsks, asks);
         this.handleDeltas(storedBids, bids);
+        const marketId = this.safeString(message, 'instId');
+        const symbol = this.safeSymbol(marketId);
         const checksum = this.safeBool(this.options, 'checksum', true);
         if (checksum) {
             const asksLength = storedAsks.length;
@@ -596,6 +602,8 @@ class okx extends okx$1 {
             const localChecksum = this.crc32(payload, true);
             if (responseChecksum !== localChecksum) {
                 const error = new errors.InvalidNonce(this.id + ' invalid checksum');
+                delete client.subscriptions[messageHash];
+                delete this.orderbooks[symbol];
                 client.reject(error, messageHash);
             }
         }
@@ -690,10 +698,10 @@ class okx extends okx$1 {
         //         ]
         //     }
         //
-        const arg = this.safeValue(message, 'arg', {});
+        const arg = this.safeDict(message, 'arg', {});
         const channel = this.safeString(arg, 'channel');
         const action = this.safeString(message, 'action');
-        const data = this.safeValue(message, 'data', []);
+        const data = this.safeList(message, 'data', []);
         const marketId = this.safeString(arg, 'instId');
         const market = this.safeMarket(marketId);
         const symbol = market['symbol'];
@@ -1523,29 +1531,21 @@ class okx extends okx$1 {
         //     { event: 'error', msg: "Illegal request: {"op":"subscribe","args":["spot/ticker:BTC-USDT"]}", code: "60012" }
         //     { event: 'error", msg: "channel:ticker,instId:BTC-USDT doesn"t exist", code: "60018" }
         //
-        const errorCode = this.safeInteger(message, 'code');
+        const errorCode = this.safeString(message, 'code');
         try {
-            if (errorCode) {
+            if (errorCode && errorCode !== '0') {
                 const feedback = this.id + ' ' + this.json(message);
                 this.throwExactlyMatchedException(this.exceptions['exact'], errorCode, feedback);
                 const messageString = this.safeValue(message, 'msg');
                 if (messageString !== undefined) {
                     this.throwBroadlyMatchedException(this.exceptions['broad'], messageString, feedback);
                 }
+                throw new errors.ExchangeError(feedback);
             }
         }
         catch (e) {
-            if (e instanceof errors.AuthenticationError) {
-                const messageHash = 'authenticated';
-                client.reject(e, messageHash);
-                if (messageHash in client.subscriptions) {
-                    delete client.subscriptions[messageHash];
-                }
-                return false;
-            }
-            else {
-                client.reject(e);
-            }
+            client.reject(e);
+            return false;
         }
         return message;
     }

package/dist/cjs/src/probit.js

@@ -86,6 +86,7 @@ class probit extends probit$1 {
                 'fetchWithdrawal': false,
                 'fetchWithdrawals': true,
                 'reduceMargin': false,
+                'sandbox': true,
                 'setLeverage': false,
                 'setMarginMode': false,
                 'setPositionMode': false,

package/dist/cjs/src/wavesexchange.js

@@ -79,6 +79,7 @@ class wavesexchange extends wavesexchange$1 {
                 'fetchTransfer': false,
                 'fetchTransfers': false,
                 'reduceMargin': false,
+                'sandbox': true,
                 'setLeverage': false,
                 'setMarginMode': false,
                 'setPositionMode': false,

package/dist/cjs/src/woo.js

@@ -104,6 +104,7 @@ class woo extends woo$1 {
                 'fetchTransfers': true,
                 'fetchWithdrawals': true,
                 'reduceMargin': false,
+                'sandbox': true,
                 'setLeverage': true,
                 'setMargin': false,
                 'setPositionMode': true,

package/dist/cjs/src/zaif.js

@@ -675,7 +675,7 @@ class zaif extends zaif$1 {
         };
     }
     customNonce() {
-        const num = (this.milliseconds() / 1000).toString();
+        const num = this.numberToString(this.milliseconds() / 1000);
         const nonce = parseFloat(num);
         return nonce.toFixed(8);
     }

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, Leverage, Leverages, Option, OptionChain, Conversion } from './src/base/types.js';
 import { BaseError, ExchangeError, AuthenticationError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, OperationRejected, NoChange, MarginModeAlreadySet, MarketClosed, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, AddressPending, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, ContractUnavailable, NotSupported, ProxyError, ExchangeClosedByUser, OperationFailed, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout } from './src/base/errors.js';
-declare const version = "4.3.14";
+declare const version = "4.3.16";
 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, AuthenticationError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, OperationRejected, NoChange, MarginModeAlreadySet, MarketClosed, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, AddressPending, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, ContractUnavailable, NotSupported, ProxyError, ExchangeClosedByUser, OperationFailed, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout } from './src/base/errors.js';
 //-----------------------------------------------------------------------------
 // this is updated by vss.js when building
-const version = '4.3.15';
+const version = '4.3.17';
 Exchange.ccxtVersion = version;
 //-----------------------------------------------------------------------------
 import ace from './src/ace.js';

package/js/src/alpaca.js

@@ -92,6 +92,7 @@ export default class alpaca extends Exchange {
                 'fetchTransactions': false,
                 'fetchTransfers': false,
                 'fetchWithdrawals': false,
+                'sandbox': true,
                 'setLeverage': false,
                 'setMarginMode': false,
                 'transfer': false,

package/js/src/ascendex.js

@@ -94,6 +94,7 @@ export default class ascendex extends Exchange {
                 'fetchWithdrawal': false,
                 'fetchWithdrawals': true,
                 'reduceMargin': true,
+                'sandbox': true,
                 'setLeverage': true,
                 'setMarginMode': true,
                 'setPositionMode': false,

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

@@ -289,6 +289,7 @@ export default class Exchange {
             publicAPI: boolean;
             privateAPI: boolean;
             CORS: any;
+            sandbox: any;
             spot: any;
             margin: any;
             swap: any;

package/js/src/base/Exchange.js

@@ -351,6 +351,7 @@ export default class Exchange {
                 'publicAPI': true,
                 'privateAPI': true,
                 'CORS': undefined,
+                'sandbox': undefined,
                 'spot': undefined,
                 'margin': undefined,
                 'swap': undefined,
@@ -5835,24 +5836,26 @@ export default class Exchange {
         let maxRetries = undefined;
         [maxRetries, params] = this.handleOptionAndParams(params, method, 'maxRetries', 3);
         let errors = 0;
-        try {
-            if (timeframe && method !== 'fetchFundingRateHistory') {
-                return await this[method](symbol, timeframe, since, limit, params);
-            }
-            else {
-                return await this[method](symbol, since, limit, params);
-            }
-        }
-        catch (e) {
-            if (e instanceof RateLimitExceeded) {
-                throw e; // if we are rate limited, we should not retry and fail fast
+        while (errors <= maxRetries) {
+            try {
+                if (timeframe && method !== 'fetchFundingRateHistory') {
+                    return await this[method](symbol, timeframe, since, limit, params);
+                }
+                else {
+                    return await this[method](symbol, since, limit, params);
+                }
             }
-            errors += 1;
-            if (errors > maxRetries) {
-                throw e;
+            catch (e) {
+                if (e instanceof RateLimitExceeded) {
+                    throw e; // if we are rate limited, we should not retry and fail fast
+                }
+                errors += 1;
+                if (errors > maxRetries) {
+                    throw e;
+                }
             }
         }
-        return undefined;
+        return [];
     }
     async fetchPaginatedCallDeterministic(method, symbol = undefined, since = undefined, limit = undefined, timeframe = undefined, params = {}, maxEntriesPerRequest = undefined) {
         let maxCalls = undefined;
@@ -5866,6 +5869,9 @@ export default class Exchange {
         if (since !== undefined) {
             currentSince = Math.max(currentSince, since);
         }
+        else {
+            currentSince = Math.max(currentSince, 1241440531000); // avoid timestamps older than 2009
+        }
         const until = this.safeInteger2(params, 'until', 'till'); // do not omit it here
         if (until !== undefined) {
             const requiredCalls = Math.ceil((until - since) / step);
@@ -5877,6 +5883,9 @@ export default class Exchange {
             if ((until !== undefined) && (currentSince >= until)) {
                 break;
             }
+            if (currentSince >= current) {
+                break;
+            }
             tasks.push(this.safeDeterministicCall(method, symbol, currentSince, maxEntriesPerRequest, timeframe, params));
             currentSince = this.sum(currentSince, step) - 1;
         }

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

@@ -3,38 +3,38 @@ declare class Precise {
     decimals: number;
     integer: bigint;
     base: any;
-    constructor(number: any, decimals?: Int);
-    mul(other: any): Precise;
-    div(other: any, precision?: number): Precise;
-    add(other: any): Precise;
-    mod(other: any): Precise;
-    sub(other: any): Precise;
+    constructor(number: bigint | string, decimals?: Int);
+    mul(other: Precise): Precise;
+    div(other: Precise, precision?: number): Precise;
+    add(other: Precise): Precise;
+    mod(other: Precise): Precise;
+    sub(other: Precise): Precise;
     abs(): Precise;
     neg(): Precise;
-    min(other: any): any;
-    max(other: any): any;
-    gt(other: any): boolean;
-    ge(other: any): boolean;
-    lt(other: any): any;
-    le(other: any): any;
+    min(other: Precise): Precise;
+    max(other: Precise): Precise;
+    gt(other: Precise): boolean;
+    ge(other: Precise): boolean;
+    lt(other: Precise): boolean;
+    le(other: Precise): boolean;
     reduce(): this;
     equals(other: any): boolean;
     toString(): string;
     static stringMul(string1: Str, string2: Str): string;
-    static stringDiv(string1: any, string2: any, precision?: number): string;
+    static stringDiv(string1: Str, string2: Str, precision?: number): string;
     static stringAdd(string1: Str, string2: Str): string;
     static stringSub(string1: Str, string2: Str): string;
-    static stringAbs(string: any): string;
-    static stringNeg(string: any): string;
+    static stringAbs(string: Str): string;
+    static stringNeg(string: Str): string;
     static stringMod(string1: Str, string2: Str): string;
     static stringEquals(string1: Str, string2: Str): boolean;
     static stringEq(string1: Str, string2: Str): boolean;
-    static stringMin(string1: Str, string2: Str): any;
-    static stringMax(string1: Str, string2: Str): any;
+    static stringMin(string1: Str, string2: Str): string;
+    static stringMax(string1: Str, string2: Str): string;
     static stringGt(string1: Str, string2: Str): boolean;
     static stringGe(string1: Str, string2: Str): boolean;
-    static stringLt(string1: Str, string2: Str): any;
-    static stringLe(string1: Str, string2: Str): any;
+    static stringLt(string1: Str, string2: Str): boolean;
+    static stringLe(string1: Str, string2: Str): boolean;
 }
 export default Precise;
 export { Precise };

package/js/src/base/Precise.js

@@ -14,8 +14,9 @@ class Precise {
             let modifier = 0;
             number = number.toLowerCase();
             if (number.indexOf('e') > -1) {
-                [number, modifier] = number.split('e');
-                modifier = parseInt(modifier.toString());
+                let modifierString = '0';
+                [number, modifierString] = number.split('e');
+                modifier = parseInt(modifierString);
             }
             const decimalIndex = number.indexOf('.');
             this.decimals = (decimalIndex > -1) ? number.length - decimalIndex - 1 : 0;

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

@@ -1,113 +1,113 @@
 declare class BaseError extends Error {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class ExchangeError extends BaseError {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class AuthenticationError extends ExchangeError {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class PermissionDenied extends AuthenticationError {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class AccountNotEnabled extends PermissionDenied {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class AccountSuspended extends AuthenticationError {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class ArgumentsRequired extends ExchangeError {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class BadRequest extends ExchangeError {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class BadSymbol extends BadRequest {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class OperationRejected extends ExchangeError {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class NoChange extends OperationRejected {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class MarginModeAlreadySet extends NoChange {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class MarketClosed extends OperationRejected {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class BadResponse extends ExchangeError {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class NullResponse extends BadResponse {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class InsufficientFunds extends ExchangeError {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class InvalidAddress extends ExchangeError {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class AddressPending extends InvalidAddress {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class InvalidOrder extends ExchangeError {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class OrderNotFound extends InvalidOrder {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class OrderNotCached extends InvalidOrder {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class CancelPending extends InvalidOrder {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class OrderImmediatelyFillable extends InvalidOrder {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class OrderNotFillable extends InvalidOrder {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class DuplicateOrderId extends InvalidOrder {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class ContractUnavailable extends InvalidOrder {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class NotSupported extends ExchangeError {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class ProxyError extends ExchangeError {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class ExchangeClosedByUser extends ExchangeError {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class OperationFailed extends BaseError {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class NetworkError extends OperationFailed {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class DDoSProtection extends NetworkError {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class RateLimitExceeded extends NetworkError {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class ExchangeNotAvailable extends NetworkError {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class OnMaintenance extends ExchangeNotAvailable {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class InvalidNonce extends NetworkError {
-    constructor(message: any);
+    constructor(message: string);
 }
 declare class RequestTimeout extends NetworkError {
-    constructor(message: any);
+    constructor(message: string);
 }
 export { BaseError, ExchangeError, AuthenticationError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, OperationRejected, NoChange, MarginModeAlreadySet, MarketClosed, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, AddressPending, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, ContractUnavailable, NotSupported, ProxyError, ExchangeClosedByUser, OperationFailed, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout };
 declare const _default: {

package/js/src/base/ws/WsClient.d.ts

@@ -1,6 +1,6 @@
 import Client from './Client.js';
 export default class WsClient extends Client {
-    connectionStarted: number;
+    connectionStarted: number | undefined;
     protocols: any;
     options: any;
     startedConnecting: boolean;

package/js/src/base/ws/WsClient.js

@@ -12,6 +12,10 @@ import { Future } from './Future.js';
 // eslint-disable-next-line no-restricted-globals
 const WebSocketPlatform = isNode ? WebSocket : self.WebSocket;
 export default class WsClient extends Client {
+    constructor() {
+        super(...arguments);
+        this.startedConnecting = false;
+    }
     createConnection() {
         if (this.verbose) {
             this.log(new Date(), 'connecting to', this.url);

package/js/src/binance.js

@@ -157,6 +157,7 @@ export default class binance extends Exchange {
                 'reduceMargin': true,
                 'repayCrossMargin': true,
                 'repayIsolatedMargin': true,
+                'sandbox': true,
                 'setLeverage': true,
                 'setMargin': false,
                 'setMarginMode': true,
@@ -2621,7 +2622,7 @@ export default class binance extends Exchange {
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @returns {object} an associative dictionary of currencies
          */
-        const fetchCurrenciesEnabled = this.safeValue(this.options, 'fetchCurrencies');
+        const fetchCurrenciesEnabled = this.safeBool(this.options, 'fetchCurrencies');
         if (!fetchCurrenciesEnabled) {
             return undefined;
         }
@@ -4545,7 +4546,7 @@ export default class binance extends Exchange {
         market = this.safeMarket(marketId, market, undefined, marketType);
         const symbol = market['symbol'];
         let side = undefined;
-        const buyerMaker = this.safeValue2(trade, 'm', 'isBuyerMaker');
+        const buyerMaker = this.safeBool2(trade, 'm', 'isBuyerMaker');
         let takerOrMaker = undefined;
         if (buyerMaker !== undefined) {
             side = buyerMaker ? 'sell' : 'buy'; // this is reversed intentionally
@@ -4853,7 +4854,7 @@ export default class binance extends Exchange {
                 uppercaseType = 'STOP_LOSS_LIMIT';
             }
         }
-        const validOrderTypes = this.safeValue(market['info'], 'orderTypes');
+        const validOrderTypes = this.safeList(market['info'], 'orderTypes');
         if (!this.inArray(uppercaseType, validOrderTypes)) {
             if (initialUppercaseType !== uppercaseType) {
                 throw new InvalidOrder(this.id + ' stopPrice parameter is not allowed for ' + symbol + ' ' + type + ' orders');
@@ -4863,7 +4864,7 @@ export default class binance extends Exchange {
             }
         }
         if (clientOrderId === undefined) {
-            const broker = this.safeValue(this.options, 'broker');
+            const broker = this.safeDict(this.options, 'broker');
             if (broker !== undefined) {
                 const brokerId = this.safeString(broker, 'spot');
                 if (brokerId !== undefined) {
@@ -7662,7 +7663,7 @@ export default class binance extends Exchange {
                 request['endTime'] = until;
             }
             const raw = await this.sapiGetFiatOrders(this.extend(request, params));
-            response = this.safeValue(raw, 'data');
+            response = this.safeList(raw, 'data', []);
             //     {
             //       "code": "000000",
             //       "message": "success",
@@ -7777,7 +7778,7 @@ export default class binance extends Exchange {
                 request['beginTime'] = since;
             }
             const raw = await this.sapiGetFiatOrders(this.extend(request, params));
-            response = this.safeValue(raw, 'data');
+            response = this.safeList(raw, 'data', []);
             //     {
             //       "code": "000000",
             //       "message": "success",
@@ -7995,7 +7996,7 @@ export default class binance extends Exchange {
             if (txType !== undefined) {
                 type = (txType === '0') ? 'deposit' : 'withdrawal';
             }
-            const legalMoneyCurrenciesById = this.safeValue(this.options, 'legalMoneyCurrenciesById');
+            const legalMoneyCurrenciesById = this.safeDict(this.options, 'legalMoneyCurrenciesById');
             code = this.safeString(legalMoneyCurrenciesById, code, code);
         }
         const status = this.parseTransactionStatusByType(this.safeString(transaction, 'status'), type);
@@ -8349,7 +8350,7 @@ export default class binance extends Exchange {
                 }
             }
             impliedNetwork = this.safeString(reverseNetworks, topLevel);
-            const impliedNetworks = this.safeValue(this.options, 'impliedNetworks', {
+            const impliedNetworks = this.safeDict(this.options, 'impliedNetworks', {
                 'ETH': { 'ERC20': 'ETH' },
                 'TRX': { 'TRC20': 'TRX' },
             });
@@ -9658,7 +9659,7 @@ export default class binance extends Exchange {
         await this.loadMarkets();
         // by default cache the leverage bracket
         // it contains useful stuff like the maintenance margin and initial margin for positions
-        const leverageBrackets = this.safeValue(this.options, 'leverageBrackets');
+        const leverageBrackets = this.safeDict(this.options, 'leverageBrackets', {});
         if ((leverageBrackets === undefined) || (reload)) {
             const defaultType = this.safeString(this.options, 'defaultType', 'future');
             const type = this.safeString(params, 'type', defaultType);

package/js/src/bingx.js

@@ -86,6 +86,7 @@ export default class bingx extends Exchange {
                 'fetchTransfers': true,
                 'fetchWithdrawals': true,
                 'reduceMargin': true,
+                'sandbox': true,
                 'setLeverage': true,
                 'setMargin': true,
                 'setMarginMode': true,

package/js/src/bitmex.js

@@ -91,6 +91,7 @@ export default class bitmex extends Exchange {
                 'fetchTransfer': false,
                 'fetchTransfers': false,
                 'reduceMargin': undefined,
+                'sandbox': true,
                 'setLeverage': true,
                 'setMargin': undefined,
                 'setMarginMode': true,