ccxt 4.3.66 → 4.3.68

package/dist/cjs/src/bitget.js

@@ -5205,8 +5205,10 @@ class bitget extends bitget$1 {
             response = JSON.parse(response);
         }
         const data = this.safeDict(response, 'data');
-        if ((data !== undefined) && !Array.isArray(data)) {
-            return this.parseOrder(data, market);
+        if ((data !== undefined)) {
+            if (!Array.isArray(data)) {
+                return this.parseOrder(data, market);
+            }
         }
         const dataList = this.safeList(response, 'data', []);
         const first = this.safeDict(dataList, 0, {});

package/dist/cjs/src/bithumb.js

@@ -203,17 +203,57 @@ class bithumb extends bithumb$1 {
          * @returns {object[]} an array of objects representing market data
          */
         const result = [];
-        const quoteCurrencies = this.safeValue(this.options, 'quoteCurrencies', {});
+        const quoteCurrencies = this.safeDict(this.options, 'quoteCurrencies', {});
         const quotes = Object.keys(quoteCurrencies);
+        const promises = [];
         for (let i = 0; i < quotes.length; i++) {
-            const quote = quotes[i];
-            const quoteId = quote;
-            const extension = this.safeValue(quoteCurrencies, quote, {});
             const request = {
-                'quoteId': quoteId,
+                'quoteId': quotes[i],
             };
-            const response = await this.publicGetTickerALLQuoteId(this.extend(request, params));
-            const data = this.safeValue(response, 'data');
+            promises.push(this.publicGetTickerALLQuoteId(this.extend(request, params)));
+            //
+            //    {
+            //        "status": "0000",
+            //        "data": {
+            //            "ETH": {
+            //                "opening_price": "0.05153399",
+            //                "closing_price": "0.05145144",
+            //                "min_price": "0.05145144",
+            //                "max_price": "0.05160781",
+            //                "units_traded": "6.541124172077830855",
+            //                "acc_trade_value": "0.33705472498492329997697755",
+            //                "prev_closing_price": "0.0515943",
+            //                "units_traded_24H": "43.368879902677400513",
+            //                "acc_trade_value_24H": "2.24165339555398079994373342",
+            //                "fluctate_24H": "-0.00018203",
+            //                "fluctate_rate_24H": "-0.35"
+            //            },
+            //            "XRP": {
+            //                "opening_price": "0.00000918",
+            //                "closing_price": "0.0000092",
+            //                "min_price": "0.00000918",
+            //                "max_price": "0.0000092",
+            //                "units_traded": "6516.949363",
+            //                "acc_trade_value": "0.0598792533602796",
+            //                "prev_closing_price": "0.00000916",
+            //                "units_traded_24H": "229161.50354738",
+            //                "acc_trade_value_24H": "2.0446589371637117",
+            //                "fluctate_24H": "0.00000049",
+            //                "fluctate_rate_24H": "5.63"
+            //            },
+            //            ...
+            //            "date": "1721675913145"
+            //        }
+            //    }
+            //
+        }
+        const results = await Promise.all(promises);
+        for (let i = 0; i < quotes.length; i++) {
+            const quote = quotes[i];
+            const quoteId = quote;
+            const response = results[i];
+            const data = this.safeDict(response, 'data');
+            const extension = this.safeDict(quoteCurrencies, quote, {});
             const currencyIds = Object.keys(data);
             for (let j = 0; j < currencyIds.length; j++) {
                 const currencyId = currencyIds[j];
@@ -282,7 +322,7 @@ class bithumb extends bithumb$1 {
     }
     parseBalance(response) {
         const result = { 'info': response };
-        const balances = this.safeValue(response, 'data');
+        const balances = this.safeDict(response, 'data');
         const codes = Object.keys(this.currencies);
         for (let i = 0; i < codes.length; i++) {
             const code = codes[i];
@@ -353,7 +393,7 @@ class bithumb extends bithumb$1 {
         //         }
         //     }
         //
-        const data = this.safeValue(response, 'data', {});
+        const data = this.safeDict(response, 'data', {});
         const timestamp = this.safeInteger(data, 'timestamp');
         return this.parseOrderBook(data, symbol, timestamp, 'bids', 'asks', 'price', 'quantity');
     }
@@ -417,15 +457,19 @@ class bithumb extends bithumb$1 {
          */
         await this.loadMarkets();
         const result = {};
-        const quoteCurrencies = this.safeValue(this.options, 'quoteCurrencies', {});
+        const quoteCurrencies = this.safeDict(this.options, 'quoteCurrencies', {});
         const quotes = Object.keys(quoteCurrencies);
+        const promises = [];
         for (let i = 0; i < quotes.length; i++) {
-            const quote = quotes[i];
-            const quoteId = quote;
             const request = {
-                'quoteId': quoteId,
+                'quoteId': quotes[i],
             };
-            const response = await this.publicGetTickerALLQuoteId(this.extend(request, params));
+            promises.push(this.publicGetTickerALLQuoteId(this.extend(request, params)));
+        }
+        const responses = await Promise.all(promises);
+        for (let i = 0; i < quotes.length; i++) {
+            const quote = quotes[i];
+            const response = responses[i];
             //
             //     {
             //         "status":"0000",
@@ -447,7 +491,7 @@ class bithumb extends bithumb$1 {
             //         }
             //     }
             //
-            const data = this.safeValue(response, 'data', {});
+            const data = this.safeDict(response, 'data', {});
             const timestamp = this.safeInteger(data, 'date');
             const tickers = this.omit(data, 'date');
             const currencyIds = Object.keys(tickers);
@@ -832,7 +876,7 @@ class bithumb extends bithumb$1 {
         //     }
         //
         const timestamp = this.safeIntegerProduct(order, 'order_date', 0.001);
-        const sideProperty = this.safeValue2(order, 'type', 'side');
+        const sideProperty = this.safeString2(order, 'type', 'side');
         const side = (sideProperty === 'bid') ? 'buy' : 'sell';
         const status = this.parseOrderStatus(this.safeString(order, 'order_status'));
         const price = this.safeString2(order, 'order_price', 'price');
@@ -863,7 +907,7 @@ class bithumb extends bithumb$1 {
             symbol = market['symbol'];
         }
         const id = this.safeString(order, 'order_id');
-        const rawTrades = this.safeValue(order, 'contract', []);
+        const rawTrades = this.safeList(order, 'contract', []);
         return this.safeOrder({
             'info': order,
             'id': id,

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

@@ -76,17 +76,17 @@ class krakenfutures extends krakenfutures$1 {
         const url = this.urls['api']['ws'];
         const messageHash = 'challenge';
         const client = this.client(url);
-        let future = this.safeValue(client.subscriptions, messageHash);
-        if (future === undefined) {
+        const future = client.future(messageHash);
+        const authenticated = this.safeValue(client.subscriptions, messageHash);
+        if (authenticated === undefined) {
             const request = {
                 'event': 'challenge',
                 'api_key': this.apiKey,
             };
             const message = this.extend(request, params);
-            future = await this.watch(url, messageHash, message, messageHash);
-            client.subscriptions[messageHash] = future;
+            this.watch(url, messageHash, message, messageHash);
         }
-        return future;
+        return await future;
     }
     async watchOrderBookForSymbols(symbols, limit = undefined, params = {}) {
         /**
@@ -1572,7 +1572,8 @@ class krakenfutures extends krakenfutures$1 {
             const signature = this.hmac(hashedChallenge, base64Secret, sha512.sha512, 'base64');
             this.options['challenge'] = challenge;
             this.options['signedChallenge'] = signature;
-            client.resolve(message, messageHash);
+            const future = this.safeValue(client.futures, messageHash);
+            future.resolve(true);
         }
         else {
             const error = new errors.AuthenticationError(this.id + ' ' + this.json(message));

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

@@ -894,7 +894,7 @@ class okx extends okx$1 {
             this.handleDelta(bookside, deltas[i]);
         }
     }
-    handleOrderBookMessage(client, message, orderbook, messageHash) {
+    handleOrderBookMessage(client, message, orderbook, messageHash, market = undefined) {
         //
         //     {
         //         "asks": [
@@ -909,6 +909,9 @@ class okx extends okx$1 {
         //         ],
         //         "instId": "BTC-USDT",
         //         "ts": "1626537446491"
+        //         "checksum": -855196043,
+        //         "prevSeqId": 123456,
+        //         "seqId": 123457
         //     }
         //
         const asks = this.safeValue(message, 'asks', []);
@@ -918,9 +921,12 @@ class okx extends okx$1 {
         this.handleDeltas(storedAsks, asks);
         this.handleDeltas(storedBids, bids);
         const marketId = this.safeString(message, 'instId');
-        const symbol = this.safeSymbol(marketId);
+        const symbol = this.safeSymbol(marketId, market);
         const checksum = this.handleOption('watchOrderBook', 'checksum', true);
+        const seqId = this.safeInteger(message, 'seqId');
         if (checksum) {
+            const prevSeqId = this.safeInteger(message, 'prevSeqId');
+            const nonce = orderbook['nonce'];
             const asksLength = storedAsks.length;
             const bidsLength = storedBids.length;
             const payloadArray = [];
@@ -937,14 +943,21 @@ class okx extends okx$1 {
             const payload = payloadArray.join(':');
             const responseChecksum = this.safeInteger(message, 'checksum');
             const localChecksum = this.crc32(payload, true);
+            let error = undefined;
+            if (prevSeqId !== -1 && nonce !== prevSeqId) {
+                error = new errors.InvalidNonce(this.id + ' watchOrderBook received invalid nonce');
+            }
             if (responseChecksum !== localChecksum) {
-                const error = new errors.ChecksumError(this.id + ' ' + this.orderbookChecksumMessage(symbol));
+                error = new errors.ChecksumError(this.id + ' ' + this.orderbookChecksumMessage(symbol));
+            }
+            if (error !== undefined) {
                 delete client.subscriptions[messageHash];
                 delete this.orderbooks[symbol];
                 client.reject(error, messageHash);
             }
         }
         const timestamp = this.safeInteger(message, 'ts');
+        orderbook['nonce'] = seqId;
         orderbook['timestamp'] = timestamp;
         orderbook['datetime'] = this.iso8601(timestamp);
         return orderbook;
@@ -1066,7 +1079,7 @@ class okx extends okx$1 {
                 const orderbook = this.orderbooks[symbol];
                 for (let i = 0; i < data.length; i++) {
                     const update = data[i];
-                    this.handleOrderBookMessage(client, update, orderbook, messageHash);
+                    this.handleOrderBookMessage(client, update, orderbook, messageHash, market);
                     client.resolve(orderbook, messageHash);
                 }
             }

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 { Int, int, Str, Strings, Num, Bool, IndexType, OrderSide, OrderType, MarketType, SubType, Dict, NullableDict, List, NullableList, Fee, OHLCV, OHLCVC, implicitReturnType, Market, Currency, Dictionary, MinMax, FeeInterface, TradingFeeInterface, MarketInterface, Trade, Order, OrderBook, Ticker, Transaction, Tickers, CurrencyInterface, Balance, BalanceAccount, Account, PartialBalances, Balances, DepositAddress, WithdrawalResponse, DepositAddressResponse, FundingRate, FundingRates, Position, BorrowInterest, LeverageTier, LedgerEntry, DepositWithdrawFeeNetwork, DepositWithdrawFee, TransferEntry, CrossBorrowRate, IsolatedBorrowRate, FundingRateHistory, OpenInterest, Liquidation, OrderRequest, CancellationRequest, FundingHistory, MarginMode, Greeks, Conversion, Option, LastPrice, Leverage, MarginModification, Leverages, LastPrices, Currencies, TradingFees, MarginModes, OptionChain, IsolatedBorrowRates, CrossBorrowRates, TransferEntries, LeverageTiers } from './src/base/types.js';
 import { BaseError, ExchangeError, AuthenticationError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, OperationRejected, NoChange, MarginModeAlreadySet, MarketClosed, InsufficientFunds, InvalidAddress, AddressPending, InvalidOrder, OrderNotFound, OrderNotCached, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, ContractUnavailable, NotSupported, InvalidProxySettings, ExchangeClosedByUser, OperationFailed, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, ChecksumError, RequestTimeout, BadResponse, NullResponse, CancelPending } from './src/base/errors.js';
-declare const version = "4.3.65";
+declare const version = "4.3.67";
 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, InsufficientFunds, InvalidAddress, AddressPending, InvalidOrder, OrderNotFound, OrderNotCached, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, ContractUnavailable, NotSupported, InvalidProxySettings, ExchangeClosedByUser, OperationFailed, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, ChecksumError, RequestTimeout, BadResponse, NullResponse, CancelPending } from './src/base/errors.js';
 //-----------------------------------------------------------------------------
 // this is updated by vss.js when building
-const version = '4.3.66';
+const version = '4.3.68';
 Exchange.ccxtVersion = version;
 //-----------------------------------------------------------------------------
 import ace from './src/ace.js';

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

@@ -84,13 +84,20 @@ interface Exchange {
     cswapV1PrivateGetTradeLeverage(params?: {}): Promise<implicitReturnType>;
     cswapV1PrivateGetTradeForceOrders(params?: {}): Promise<implicitReturnType>;
     cswapV1PrivateGetTradeAllFillOrders(params?: {}): Promise<implicitReturnType>;
+    cswapV1PrivateGetTradeOpenOrders(params?: {}): Promise<implicitReturnType>;
+    cswapV1PrivateGetTradeOrderDetail(params?: {}): Promise<implicitReturnType>;
+    cswapV1PrivateGetTradeOrderHistory(params?: {}): Promise<implicitReturnType>;
+    cswapV1PrivateGetTradeMarginType(params?: {}): Promise<implicitReturnType>;
     cswapV1PrivateGetUserCommissionRate(params?: {}): Promise<implicitReturnType>;
     cswapV1PrivateGetUserPositions(params?: {}): Promise<implicitReturnType>;
     cswapV1PrivateGetUserBalance(params?: {}): Promise<implicitReturnType>;
     cswapV1PrivatePostTradeOrder(params?: {}): Promise<implicitReturnType>;
     cswapV1PrivatePostTradeLeverage(params?: {}): Promise<implicitReturnType>;
     cswapV1PrivatePostTradeCloseAllPositions(params?: {}): Promise<implicitReturnType>;
+    cswapV1PrivatePostTradeMarginType(params?: {}): Promise<implicitReturnType>;
+    cswapV1PrivatePostTradePositionMargin(params?: {}): Promise<implicitReturnType>;
     cswapV1PrivateDeleteTradeAllOpenOrders(params?: {}): Promise<implicitReturnType>;
+    cswapV1PrivateDeleteTradeCancelOrder(params?: {}): Promise<implicitReturnType>;
     contractV1PrivateGetAllPosition(params?: {}): Promise<implicitReturnType>;
     contractV1PrivateGetAllOrders(params?: {}): Promise<implicitReturnType>;
     contractV1PrivateGetBalance(params?: {}): Promise<implicitReturnType>;

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

@@ -7,6 +7,7 @@ import type { Market, Trade, Ticker, OHLCV, OHLCVC, Order, OrderBook, Balance, B
 export type { Market, Trade, Fee, Ticker, OHLCV, OHLCVC, Order, OrderBook, Balance, Balances, Dictionary, Transaction, DepositAddressResponse, Currency, MinMax, IndexType, Int, Bool, OrderType, OrderSide, Position, LedgerEntry, BorrowInterest, OpenInterest, LeverageTier, TransferEntry, CrossBorrowRate, FundingRateHistory, Liquidation, FundingHistory, OrderRequest, MarginMode, Tickers, Greeks, Option, OptionChain, Str, Num, MarketInterface, CurrencyInterface, BalanceAccount, MarginModes, MarketType, Leverage, Leverages, LastPrice, LastPrices, Account, Strings, Conversion } from './types.js';
 import { ArrayCache, ArrayCacheByTimestamp } from './ws/Cache.js';
 import { OrderBook as Ob } from './ws/OrderBook.js';
+import Client from './ws/Client.js';
 /**
  * @class Exchange
  */
@@ -648,7 +649,7 @@ export default class Exchange {
     indexedOrderBook(snapshot?: {}, depth?: number): IndexedOrderBook;
     countedOrderBook(snapshot?: {}, depth?: number): CountedOrderBook;
     handleMessage(client: any, message: any): void;
-    ping(client: any): any;
+    ping(client: Client): any;
     client(url: string): WsClient;
     watchMultiple(url: string, messageHashes: string[], message?: any, subscribeHashes?: any, subscription?: any): import("./ws/Future.js").FutureInterface;
     watch(url: string, messageHash: string, message?: any, subscribeHash?: any, subscription?: any): any;
@@ -658,7 +659,7 @@ export default class Exchange {
     close(): Promise<void>;
     loadOrderBook(client: any, messageHash: string, symbol: string, limit?: Int, params?: {}): Promise<void>;
     convertToBigInt(value: string): bigint;
-    stringToCharsArray(value: any): any;
+    stringToCharsArray(value: string): string[];
     valueIsDefined(value: any): boolean;
     arraySlice(array: any, first: any, second?: any): any;
     getProperty(obj: any, property: any, defaultValue?: any): any;
@@ -668,9 +669,9 @@ export default class Exchange {
     ethAbiEncode(types: any, args: any): Uint8Array;
     ethEncodeStructuredData(domain: any, messageTypes: any, messageData: any): Uint8Array;
     intToBase16(elem: any): string;
-    extendExchangeOptions(newOptions: any): void;
+    extendExchangeOptions(newOptions: Dict): void;
     createSafeDictionary(): {};
-    randomBytes(length: any): string;
+    randomBytes(length: number): string;
     safeBoolN(dictionaryOrList: any, keys: IndexType[], defaultValue?: boolean): boolean | undefined;
     safeBool2(dictionary: any, key1: IndexType, key2: IndexType, defaultValue?: boolean): boolean | undefined;
     safeBool(dictionary: any, key: IndexType, defaultValue?: boolean): boolean | undefined;
@@ -722,7 +723,7 @@ export default class Exchange {
     parseTrade(trade: Dict, market?: Market): Trade;
     parseTransaction(transaction: Dict, currency?: Currency): Transaction;
     parseTransfer(transfer: Dict, currency?: Currency): TransferEntry;
-    parseAccount(account: any): Account;
+    parseAccount(account: Dict): Account;
     parseLedgerEntry(item: Dict, currency?: Currency): object;
     parseOrder(order: Dict, market?: Market): Order;
     fetchCrossBorrowRates(params?: {}): Promise<CrossBorrowRates>;
@@ -796,11 +797,11 @@ export default class Exchange {
         info: Dictionary<any>;
     };
     safeCurrencyStructure(currency: object): CurrencyInterface;
-    safeMarketStructure(market?: any): MarketInterface;
+    safeMarketStructure(market?: Dict): MarketInterface;
     setMarkets(markets: any, currencies?: any): Dictionary<any>;
     getDescribeForExtendedWsExchange(currentRestInstance: any, parentRestInstance: any, wsBaseDescribe: Dictionary<any>): any;
-    safeBalance(balance: object): Balances;
-    safeOrder(order: object, market?: Market): Order;
+    safeBalance(balance: Dict): Balances;
+    safeOrder(order: Dict, market?: Market): Order;
     parseOrders(orders: object, market?: Market, since?: Int, limit?: Int, params?: {}): Order[];
     calculateFee(symbol: string, type: string, side: string, amount: number, price: number, takerOrMaker?: string, params?: {}): {
         type: string;
@@ -808,12 +809,12 @@ export default class Exchange {
         rate: number;
         cost: number;
     };
-    safeLiquidation(liquidation: object, market?: Market): Liquidation;
-    safeTrade(trade: object, market?: Market): Trade;
+    safeLiquidation(liquidation: Dict, market?: Market): Liquidation;
+    safeTrade(trade: Dict, market?: Market): Trade;
     findNearestCeiling(arr: number[], providedValue: number): number;
     invertFlatStringDictionary(dict: any): {};
     reduceFeesByCurrency(fees: any): any[];
-    safeTicker(ticker: object, market?: Market): Ticker;
+    safeTicker(ticker: Dict, market?: Market): Ticker;
     fetchBorrowRate(code: string, amount: any, params?: {}): Promise<{}>;
     repayCrossMargin(code: string, amount: any, params?: {}): Promise<{}>;
     repayIsolatedMargin(symbol: string, code: string, amount: any, params?: {}): Promise<{}>;
@@ -847,7 +848,7 @@ export default class Exchange {
     parseOHLCVs(ohlcvs: object[], market?: any, timeframe?: string, since?: Int, limit?: Int): OHLCV[];
     parseLeverageTiers(response: any, symbols?: string[], marketIdKey?: any): LeverageTiers;
     loadTradingLimits(symbols?: Strings, reload?: boolean, params?: {}): Promise<Dictionary<any>>;
-    safePosition(position: any): Position;
+    safePosition(position: Dict): Position;
     parsePositions(positions: any[], symbols?: string[], params?: {}): Position[];
     parseAccounts(accounts: any[], params?: {}): Account[];
     parseTrades(trades: any[], market?: Market, since?: Int, limit?: Int, params?: {}): Trade[];
@@ -1092,7 +1093,7 @@ export default class Exchange {
     sortCursorPaginatedResult(result: any): any;
     removeRepeatedElementsFromArray(input: any): any;
     handleUntilOption(key: string, request: any, params: any, multiplier?: number): any[];
-    safeOpenInterest(interest: any, market?: Market): OpenInterest;
+    safeOpenInterest(interest: Dict, market?: Market): OpenInterest;
     parseLiquidation(liquidation: any, market?: Market): Liquidation;
     parseLiquidations(liquidations: Dict[], market?: Market, since?: Int, limit?: Int): Liquidation[];
     parseGreeks(greeks: Dict, market?: Market): Greeks;

package/js/src/base/Exchange.js

@@ -1165,7 +1165,7 @@ export default class Exchange {
         return new CountedOrderBook(snapshot, depth);
     }
     handleMessage(client, message) { } // stub to override
-    // ping (client) {} // stub to override
+    // ping (client: Client) {} // stub to override
     ping(client) {
         return undefined;
     }
@@ -1575,8 +1575,10 @@ export default class Exchange {
         if (value === undefined) {
             return defaultValue;
         }
-        if (typeof value === 'object') {
-            return value;
+        if ((typeof value === 'object')) {
+            if (!Array.isArray(value)) {
+                return value;
+            }
         }
         return defaultValue;
     }
@@ -3465,7 +3467,7 @@ export default class Exchange {
         }
         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.safeDict(this.options, 'defaultNetwork');
+            const defaultNetwork = this.safeString(this.options, 'defaultNetwork');
             if (defaultNetwork !== undefined) {
                 defaultNetworkCode = defaultNetwork;
             }

package/js/src/base/functions/type.js

@@ -82,7 +82,7 @@ const safeInteger2 = (o, k1, k2, $default) => {
     return isNumber(n) ? n : $default;
 };
 const safeIntegerProduct2 = (o, k1, k2, $factor, $default) => {
-    const n = asInteger(prop2(o, k1, k2));
+    const n = asFloat(prop2(o, k1, k2));
     return isNumber(n) ? parseInt(n * $factor) : $default;
 };
 const safeTimestamp2 = (o, k1, k2, $default) => {
@@ -129,7 +129,7 @@ const safeIntegerN = (o, k, $default) => {
     return isNumber(n) ? n : $default;
 };
 const safeIntegerProductN = (o, k, $factor, $default) => {
-    const n = asInteger(getValueFromKeysInArray(o, k));
+    const n = asFloat(getValueFromKeysInArray(o, k));
     return isNumber(n) ? parseInt(n * $factor) : $default;
 };
 const safeTimestampN = (o, k, $default) => {

package/js/src/bingx.d.ts

@@ -86,6 +86,8 @@ export default class bingx extends Exchange {
     fetchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchOpenOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchClosedOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    fetchCanceledOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    fetchCanceledAndClosedOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     transfer(code: string, amount: number, fromAccount: string, toAccount: string, params?: {}): Promise<TransferEntry>;
     fetchTransfers(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<TransferEntries>;
     parseTransfer(transfer: Dict, currency?: Currency): TransferEntry;