ccxt 4.3.65 → 4.3.67

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

@@ -17,7 +17,7 @@ class hyperliquid extends hyperliquid$1 {
                 'watchOrderBook': true,
                 'watchOrders': true,
                 'watchTicker': false,
-                'watchTickers': false,
+                'watchTickers': true,
                 'watchTrades': true,
                 'watchPosition': false,
             },
@@ -118,6 +118,32 @@ class hyperliquid extends hyperliquid$1 {
         const messageHash = 'orderbook:' + symbol;
         client.resolve(orderbook, messageHash);
     }
+    async watchTickers(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name hyperliquid#watchTickers
+         * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
+         * @param {string[]} symbols unified symbol of the market to fetch the ticker for
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+         */
+        await this.loadMarkets();
+        symbols = this.marketSymbols(symbols, undefined, true);
+        const messageHash = 'tickers';
+        const url = this.urls['api']['ws']['public'];
+        const request = {
+            'method': 'subscribe',
+            'subscription': {
+                'type': 'webData2',
+                'user': '0x0000000000000000000000000000000000000000',
+            },
+        };
+        const tickers = await this.watch(url, messageHash, this.extend(request, params), messageHash);
+        if (this.newUpdates) {
+            return this.filterByArrayTickers(tickers, 'symbol', symbols);
+        }
+        return this.tickers;
+    }
     async watchMyTrades(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -153,6 +179,81 @@ class hyperliquid extends hyperliquid$1 {
         }
         return this.filterBySymbolSinceLimit(trades, symbol, since, limit, true);
     }
+    handleWsTickers(client, message) {
+        //
+        //     {
+        //         "channel": "webData2",
+        //         "data": {
+        //             "meta": {
+        //                 "universe": [
+        //                     {
+        //                         "szDecimals": 5,
+        //                         "name": "BTC",
+        //                         "maxLeverage": 50,
+        //                         "onlyIsolated": false
+        //                     },
+        //                     ...
+        //                 ],
+        //             },
+        //             "assetCtxs": [
+        //                 {
+        //                     "funding": "0.00003005",
+        //                     "openInterest": "2311.50778",
+        //                     "prevDayPx": "63475.0",
+        //                     "dayNtlVlm": "468043329.64289033",
+        //                     "premium": "0.00094264",
+        //                     "oraclePx": "64712.0",
+        //                     "markPx": "64774.0",
+        //                     "midPx": "64773.5",
+        //                     "impactPxs": [
+        //                         "64773.0",
+        //                         "64774.0"
+        //                     ]
+        //                 },
+        //                 ...
+        //             ],
+        //             "spotAssetCtxs": [
+        //                 {
+        //                     "prevDayPx": "0.20937",
+        //                     "dayNtlVlm": "11188888.61984999",
+        //                     "markPx": "0.19722",
+        //                     "midPx": "0.197145",
+        //                     "circulatingSupply": "598760557.12072003",
+        //                     "coin": "PURR/USDC"
+        //                 },
+        //                 ...
+        //             ],
+        //         }
+        //     }
+        //
+        // spot
+        const rawData = this.safeDict(message, 'data', {});
+        const spotAssets = this.safeList(rawData, 'spotAssetCtxs', []);
+        const parsedTickers = [];
+        for (let i = 0; i < spotAssets.length; i++) {
+            const assetObject = spotAssets[i];
+            const marketId = this.safeString(assetObject, 'coin');
+            const market = this.safeMarket(marketId, undefined, undefined, 'spot');
+            const ticker = this.parseWsTicker(assetObject, market);
+            parsedTickers.push(ticker);
+        }
+        // perpetuals
+        const meta = this.safeDict(rawData, 'meta', {});
+        const universe = this.safeList(meta, 'universe', []);
+        const assetCtxs = this.safeList(rawData, 'assetCtxs', []);
+        for (let i = 0; i < universe.length; i++) {
+            const data = this.extend(this.safeDict(universe, i, {}), this.safeDict(assetCtxs, i, {}));
+            const id = data['name'] + '/USDC:USDC';
+            const market = this.safeMarket(id, undefined, undefined, 'swap');
+            const ticker = this.parseWsTicker(data, market);
+            parsedTickers.push(ticker);
+        }
+        const tickers = this.indexBy(parsedTickers, 'symbol');
+        client.resolve(tickers, 'tickers');
+    }
+    parseWsTicker(rawTicker, market = undefined) {
+        return this.parseTicker(rawTicker, market);
+    }
     handleMyTrades(client, message) {
         //
         //     {
@@ -522,6 +623,7 @@ class hyperliquid extends hyperliquid$1 {
             'candle': this.handleOHLCV,
             'orderUpdates': this.handleOrder,
             'userFills': this.handleMyTrades,
+            'webData2': this.handleWsTickers,
         };
         const exacMethod = this.safeValue(methods, topic);
         if (exacMethod !== undefined) {

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);
                 }
             }
@@ -1637,7 +1650,7 @@ class okx extends okx$1 {
         await this.loadMarkets();
         await this.authenticate();
         const url = this.getUrl('private', 'private');
-        const messageHash = this.nonce().toString();
+        const messageHash = this.milliseconds().toString();
         let op = undefined;
         [op, params] = this.handleOptionAndParams(params, 'createOrderWs', 'op', 'batch-orders');
         const args = this.createOrderRequest(symbol, type, side, amount, price, params);
@@ -1707,7 +1720,7 @@ class okx extends okx$1 {
         await this.loadMarkets();
         await this.authenticate();
         const url = this.getUrl('private', 'private');
-        const messageHash = this.nonce().toString();
+        const messageHash = this.milliseconds().toString();
         let op = undefined;
         [op, params] = this.handleOptionAndParams(params, 'editOrderWs', 'op', 'amend-order');
         const args = this.editOrderRequest(id, symbol, type, side, amount, price, params);
@@ -1736,7 +1749,7 @@ class okx extends okx$1 {
         await this.loadMarkets();
         await this.authenticate();
         const url = this.getUrl('private', 'private');
-        const messageHash = this.nonce().toString();
+        const messageHash = this.milliseconds().toString();
         const clientOrderId = this.safeString2(params, 'clOrdId', 'clientOrderId');
         params = this.omit(params, ['clientOrderId', 'clOrdId']);
         const arg = {
@@ -1776,7 +1789,7 @@ class okx extends okx$1 {
         await this.loadMarkets();
         await this.authenticate();
         const url = this.getUrl('private', 'private');
-        const messageHash = this.nonce().toString();
+        const messageHash = this.milliseconds().toString();
         const args = [];
         for (let i = 0; i < idsLength; i++) {
             const arg = {
@@ -1812,7 +1825,7 @@ class okx extends okx$1 {
             throw new errors.BadRequest(this.id + 'cancelAllOrdersWs is only applicable to Option in Portfolio Margin mode, and MMP privilege is required.');
         }
         const url = this.getUrl('private', 'private');
-        const messageHash = this.nonce().toString();
+        const messageHash = this.milliseconds().toString();
         const request = {
             'id': messageHash,
             'op': 'mass-cancel',

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.64";
+declare const version = "4.3.66";
 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.65';
+const version = '4.3.67';
 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

@@ -785,7 +785,7 @@ export default class Exchange {
                         // @ts-ignore
                         this.httpProxyAgentModule = await import(/* webpackIgnore: true */ 'http-proxy-agent');
                         // @ts-ignore
-                        this.httpProxyAgentModule = await import(/* webpackIgnore: true */ 'https-proxy-agent');
+                        this.httpsProxyAgentModule = await import(/* webpackIgnore: true */ 'https-proxy-agent');
                     }
                     catch (e) { }
                 }
@@ -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;
     }

package/js/src/bingx.js

@@ -286,6 +286,10 @@ export default class bingx extends Exchange {
                                 'trade/leverage': 2,
                                 'trade/forceOrders': 2,
                                 'trade/allFillOrders': 2,
+                                'trade/openOrders': 2,
+                                'trade/orderDetail': 2,
+                                'trade/orderHistory': 2,
+                                'trade/marginType': 2,
                                 'user/commissionRate': 2,
                                 'user/positions': 2,
                                 'user/balance': 2,
@@ -294,9 +298,12 @@ export default class bingx extends Exchange {
                                 'trade/order': 2,
                                 'trade/leverage': 2,
                                 'trade/closeAllPositions': 2,
+                                'trade/marginType': 2,
+                                'trade/positionMargin': 2,
                             },
                             'delete': {
                                 'trade/allOpenOrders': 2,
+                                'trade/cancelOrder': 2,
                             },
                         },
                     },
@@ -3007,7 +3014,8 @@ export default class bingx extends Exchange {
         //        "clientOrderID": ""
         //    }
         //
-        // inverse swap cancelAllOrders
+        // inverse swap cancelAllOrders, cancelOrder
+        // inverse swap cancelAllOrders, cancelOrder, fetchOpenOrders
         //
         //     {
         //         "symbol": "SOL-USD",
@@ -3169,13 +3177,14 @@ export default class bingx extends Exchange {
          * @method
          * @name bingx#cancelOrder
          * @description cancels an open order
-         * @see https://bingx-api.github.io/docs/#/spot/trade-api.html#Cancel%20an%20Order
-         * @see https://bingx-api.github.io/docs/#/swapV2/trade-api.html#Cancel%20an%20Order
+         * @see https://bingx-api.github.io/docs/#/en-us/spot/trade-api.html#Cancel%20Order
+         * @see https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Cancel%20Order
+         * @see https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Cancel%20an%20Order
          * @param {string} id order id
          * @param {string} symbol unified symbol of the market the order was made in
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @param {string} [params.clientOrderId] a unique id for the order
-         * @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
+         * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
          */
         if (symbol === undefined) {
             throw new ArgumentsRequired(this.id + ' cancelOrder() requires a symbol argument');
@@ -3194,12 +3203,20 @@ export default class bingx extends Exchange {
             request['orderId'] = id;
         }
         let response = undefined;
-        const [marketType, query] = this.handleMarketTypeAndParams('cancelOrder', market, params);
-        if (marketType === 'spot') {
-            response = await this.spotV1PrivatePostTradeCancel(this.extend(request, query));
+        let type = undefined;
+        let subType = undefined;
+        [type, params] = this.handleMarketTypeAndParams('cancelOrder', market, params);
+        [subType, params] = this.handleSubTypeAndParams('cancelOrder', market, params);
+        if (type === 'spot') {
+            response = await this.spotV1PrivatePostTradeCancel(this.extend(request, params));
         }
         else {
-            response = await this.swapV2PrivateDeleteTradeOrder(this.extend(request, query));
+            if (subType === 'inverse') {
+                response = await this.cswapV1PrivateDeleteTradeCancelOrder(this.extend(request, params));
+            }
+            else {
+                response = await this.swapV2PrivateDeleteTradeOrder(this.extend(request, params));
+            }
         }
         //
         // spot
@@ -3220,7 +3237,59 @@ export default class bingx extends Exchange {
         //       }
         //   }
         //
-        // swap
+        // inverse swap
+        //
+        //     {
+        //         "code": 0,
+        //         "msg": "",
+        //         "data": {
+        //             "order": {
+        //                 "symbol": "SOL-USD",
+        //                 "orderId": "1816002957423951872",
+        //                 "side": "BUY",
+        //                 "positionSide": "Long",
+        //                 "type": "Pending",
+        //                 "quantity": 0,
+        //                 "origQty": "0",
+        //                 "price": "150",
+        //                 "executedQty": "0",
+        //                 "avgPrice": "0",
+        //                 "cumQuote": "0",
+        //                 "stopPrice": "",
+        //                 "profit": "0.0000",
+        //                 "commission": "0.000000",
+        //                 "status": "CANCELLED",
+        //                 "time": 1721803819410,
+        //                 "updateTime": 1721803819427,
+        //                 "clientOrderId": "",
+        //                 "leverage": "",
+        //                 "takeProfit": {
+        //                     "type": "",
+        //                     "quantity": 0,
+        //                     "stopPrice": 0,
+        //                     "price": 0,
+        //                     "workingType": "",
+        //                     "stopGuaranteed": ""
+        //                 },
+        //                 "stopLoss": {
+        //                     "type": "",
+        //                     "quantity": 0,
+        //                     "stopPrice": 0,
+        //                     "price": 0,
+        //                     "workingType": "",
+        //                     "stopGuaranteed": ""
+        //                 },
+        //                 "advanceAttr": 0,
+        //                 "positionID": 0,
+        //                 "takeProfitEntrustPrice": 0,
+        //                 "stopLossEntrustPrice": 0,
+        //                 "orderType": "",
+        //                 "workingType": ""
+        //             }
+        //         }
+        //     }
+        //
+        // linear swap
         //
         //    {
         //        "code": 0,
@@ -3247,9 +3316,9 @@ export default class bingx extends Exchange {
         //        }
         //    }
         //
-        const data = this.safeValue(response, 'data');
-        const first = this.safeDict(data, 'order', data);
-        return this.parseOrder(first, market);
+        const data = this.safeDict(response, 'data', {});
+        const order = this.safeDict(data, 'order', data);
+        return this.parseOrder(order, market);
     }
     async cancelAllOrders(symbol = undefined, params = {}) {
         /**
@@ -3729,9 +3798,10 @@ export default class bingx extends Exchange {
         /**
          * @method
          * @name bingx#fetchOpenOrders
-         * @see https://bingx-api.github.io/docs/#/spot/trade-api.html#Query%20Open%20Orders
-         * @see https://bingx-api.github.io/docs/#/swapV2/trade-api.html#Query%20all%20current%20pending%20orders
          * @description fetch all unfilled currently open orders
+         * @see https://bingx-api.github.io/docs/#/en-us/spot/trade-api.html#Current%20Open%20Orders
+         * @see https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Current%20All%20Open%20Orders
+         * @see https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Query%20all%20current%20pending%20orders
          * @param {string} symbol unified market symbol
          * @param {int} [since] the earliest time in ms to fetch open orders for
          * @param {int} [limit] the maximum number of open order structures to retrieve
@@ -3745,13 +3815,21 @@ export default class bingx extends Exchange {
             market = this.market(symbol);
             request['symbol'] = market['id'];
         }
+        let type = undefined;
+        let subType = undefined;
         let response = undefined;
-        const [marketType, query] = this.handleMarketTypeAndParams('fetchOpenOrders', market, params);
-        if (marketType === 'spot') {
-            response = await this.spotV1PrivateGetTradeOpenOrders(this.extend(request, query));
+        [type, params] = this.handleMarketTypeAndParams('fetchOpenOrders', market, params);
+        [subType, params] = this.handleSubTypeAndParams('fetchOpenOrders', market, params);
+        if (type === 'spot') {
+            response = await this.spotV1PrivateGetTradeOpenOrders(this.extend(request, params));
         }
         else {
-            response = await this.swapV2PrivateGetTradeOpenOrders(this.extend(request, query));
+            if (subType === 'inverse') {
+                response = await this.cswapV1PrivateGetTradeOpenOrders(this.extend(request, params));
+            }
+            else {
+                response = await this.swapV2PrivateGetTradeOpenOrders(this.extend(request, params));
+            }
         }
         //
         //  spot
@@ -3779,7 +3857,61 @@ export default class bingx extends Exchange {
         //        }
         //    }
         //
-        // swap
+        // inverse swap
+        //
+        //     {
+        //         "code": 0,
+        //         "msg": "",
+        //         "data": {
+        //             "orders": [
+        //                 {
+        //                     "symbol": "SOL-USD",
+        //                     "orderId": "1816013900044320768",
+        //                     "side": "BUY",
+        //                     "positionSide": "Long",
+        //                     "type": "LIMIT",
+        //                     "quantity": 1,
+        //                     "origQty": "",
+        //                     "price": "150",
+        //                     "executedQty": "0",
+        //                     "avgPrice": "0.000",
+        //                     "cumQuote": "",
+        //                     "stopPrice": "",
+        //                     "profit": "0.0000",
+        //                     "commission": "0.0000",
+        //                     "status": "Pending",
+        //                     "time": 1721806428334,
+        //                     "updateTime": 1721806428352,
+        //                     "clientOrderId": "",
+        //                     "leverage": "",
+        //                     "takeProfit": {
+        //                         "type": "TAKE_PROFIT",
+        //                         "quantity": 0,
+        //                         "stopPrice": 0,
+        //                         "price": 0,
+        //                         "workingType": "MARK_PRICE",
+        //                         "stopGuaranteed": ""
+        //                     },
+        //                     "stopLoss": {
+        //                         "type": "STOP",
+        //                         "quantity": 0,
+        //                         "stopPrice": 0,
+        //                         "price": 0,
+        //                         "workingType": "MARK_PRICE",
+        //                         "stopGuaranteed": ""
+        //                     },
+        //                     "advanceAttr": 0,
+        //                     "positionID": 0,
+        //                     "takeProfitEntrustPrice": 0,
+        //                     "stopLossEntrustPrice": 0,
+        //                     "orderType": "",
+        //                     "workingType": "MARK_PRICE"
+        //                 }
+        //             ]
+        //         }
+        //     }
+        //
+        // linear swap
         //
         //    {
         //        "code": 0,