ccxt 4.5.36 → 4.5.38

package/js/src/hyperliquid.js

@@ -6,7 +6,7 @@
 
 //  ---------------------------------------------------------------------------
 import Exchange from './abstract/hyperliquid.js';
-import { ExchangeError, ArgumentsRequired, NotSupported, InvalidOrder, OrderNotFound, BadRequest, InsufficientFunds } from './base/errors.js';
+import { ExchangeError, ArgumentsRequired, NotSupported, InvalidOrder, OrderNotFound, BadRequest, InsufficientFunds, RateLimitExceeded } from './base/errors.js';
 import { Precise } from './base/Precise.js';
 import { ROUND, SIGNIFICANT_DIGITS, DECIMAL_PLACES, TICK_SIZE } from './base/functions/number.js';
 import { keccak_256 as keccak } from './static_dependencies/noble-hashes/sha3.js';
@@ -214,6 +214,9 @@ export default class hyperliquid extends Exchange {
                     'Insufficient spot balance asset': InsufficientFunds,
                     'Insufficient balance for withdrawal': InsufficientFunds,
                     'Insufficient balance for token transfer': InsufficientFunds,
+                    'TWAP order value too small. Min is $1200, which is $10 per minute.': InvalidOrder,
+                    'TWAP was never placed, already canceled, or filled.': OrderNotFound,
+                    'Too many cumulative requests sent': RateLimitExceeded, // {"status":"err","response":"Too many cumulative requests sent (37986 > 10436) for cumulative volume traded $437.92. Place taker orders to free up 1 request per USDC traded."}
                 },
             },
             'precisionMode': TICK_SIZE,
@@ -1709,6 +1712,17 @@ export default class hyperliquid extends Exchange {
         };
         return this.signUserSignedAction(messageTypes, message);
     }
+    buildUserAbstractionSig(message) {
+        const messageTypes = {
+            'HyperliquidTransaction:UserSetAbstraction': [
+                { 'name': 'hyperliquidChain', 'type': 'string' },
+                { 'name': 'user', 'type': 'address' },
+                { 'name': 'abstraction', 'type': 'string' },
+                { 'name': 'nonce', 'type': 'uint64' },
+            ],
+        };
+        return this.signUserSignedAction(messageTypes, message);
+    }
     buildApproveBuilderFeeSig(message) {
         const messageTypes = {
             'HyperliquidTransaction:ApproveBuilderFee': [
@@ -1809,11 +1823,70 @@ export default class hyperliquid extends Exchange {
         }
         return true;
     }
+    /**
+     * @method
+     * @name hyperliquid#setUserAbstraction
+     * @description set user abstraction mode
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#set-user-abstraction
+     * @param {string} abstraction one of the strings ["disabled", "unifiedAccount", "portfolioMargin"],
+     * @param {object} [params]
+     * @param {string} [params.type] 'userSetAbstraction' or 'agentSetAbstraction' default is 'userSetAbstraction'
+     * @returns dictionary response from the exchange
+     */
+    async setUserAbstraction(abstraction, params = {}) {
+        let userAddress = undefined;
+        [userAddress, params] = this.handlePublicAddress('setUserAbstraction', params);
+        const nonce = this.milliseconds();
+        const isSandboxMode = this.safeBool(this.options, 'sandboxMode', false);
+        const type = this.safeString(params, 'type', 'userSetAbstraction');
+        params = this.omit(params, 'type');
+        const payload = {
+            'hyperliquidChain': isSandboxMode ? 'Testnet' : 'Mainnet',
+            'user': userAddress,
+            'abstraction': abstraction,
+            'nonce': nonce,
+        };
+        const sig = this.buildUserAbstractionSig(payload);
+        const action = {
+            'hyperliquidChain': payload['hyperliquidChain'],
+            'signatureChainId': '0x66eee',
+            'abstraction': payload['abstraction'],
+            'user': payload['user'],
+            'nonce': nonce,
+            'type': type,
+        };
+        const request = {
+            'action': action,
+            'nonce': nonce,
+            'signature': sig,
+            'vaultAddress': undefined,
+        };
+        //
+        // {
+        //     "status": "ok",
+        //     "response": {
+        //         "type": "default"
+        //     }
+        // }
+        //
+        return await this.privatePostExchange(request);
+    }
+    /**
+     * @method
+     * @name hyperliquid#enableUserDexAbstraction
+     * @description If set, actions on HIP-3 perps will automatically transfer collateral from validator-operated USDC perps balance for HIP-3 DEXs where USDC is the collateral token, and spot otherwise
+     * @param enabled
+     * @param params
+     * @param {string} [params.type] 'userDexAbstraction' or 'agentEnableDexAbstraction' default is 'userDexAbstraction'
+     * @returns dictionary response from the exchange
+     */
     async enableUserDexAbstraction(enabled, params = {}) {
         let userAddress = undefined;
         [userAddress, params] = this.handlePublicAddress('enableUserDexAbstraction', params);
         const nonce = this.milliseconds();
         const isSandboxMode = this.safeBool(this.options, 'sandboxMode', false);
+        const type = this.safeString(params, 'type', 'userDexAbstraction');
+        params = this.omit(params, 'type');
         const payload = {
             'hyperliquidChain': isSandboxMode ? 'Testnet' : 'Mainnet',
             'user': userAddress,
@@ -1827,7 +1900,7 @@ export default class hyperliquid extends Exchange {
             'enabled': payload['enabled'],
             'user': payload['user'],
             'nonce': nonce,
-            'type': 'userDexAbstraction',
+            'type': type,
         };
         const request = {
             'action': action,
@@ -1845,6 +1918,29 @@ export default class hyperliquid extends Exchange {
         //
         return await this.privatePostExchange(request);
     }
+    /**
+     * @method
+     * @name hyperliquid#setAgentAbstraction
+     * @description set agent abstraction mode
+     * @param {string} abstraction one of the strings ["i", "u", "p"] where "i" is "disabled", "u" is "unifiedAccount", and "p" is "portfolioMargin"
+     * @param {object} [params]
+     * @returns dictionary response from the exchange
+     */
+    async setAgentAbstraction(abstraction, params = {}) {
+        const nonce = this.milliseconds();
+        const request = {
+            'nonce': nonce,
+        };
+        const action = {
+            'type': 'agentSetAbstraction',
+            'abstraction': abstraction,
+        };
+        const signature = this.signL1Action(action, nonce);
+        request['action'] = action;
+        request['signature'] = signature;
+        const response = await this.privatePostExchange(this.extend(request, params));
+        return response;
+    }
     /**
      * @method
      * @name hyperliquid#createOrder
@@ -1872,6 +1968,82 @@ export default class hyperliquid extends Exchange {
         const orders = await this.createOrders([order], globalParams);
         return orders[0];
     }
+    /**
+     * @method
+     * @name hyperliquid#createTwapOrder
+     * @description create a trade order that is executed as a TWAP order over a specified duration.
+     * @param {string} symbol unified symbol of the market to create an order in
+     * @param {string} side 'buy' or 'sell'
+     * @param {float} amount how much of currency you want to trade in units of base currency
+     * @param {int} duration the duration of the TWAP order in milliseconds
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {bool} [params.randomize] whether to randomize the time intervals of the TWAP order slices (default is false, meaning equal intervals)
+     * @param {bool} [params.reduceOnly] true or false whether the order is reduce-only
+     * @param {int} [params.expiresAfter] time in ms after which the twap order expires
+     * @param {string} [params.vaultAddress] the vault address for order
+     * @returns {object} an [order structure]{@link https://docs.ccxt.com/?id=order-structure}
+     */
+    async createTwapOrder(symbol, side, amount, duration, params = {}) {
+        await this.loadMarkets();
+        await this.initializeClient();
+        const market = this.market(symbol);
+        const nonce = this.milliseconds();
+        const isBuy = (side === 'BUY');
+        let vaultAddress = undefined;
+        const randomize = this.safeBool(params, 'randomize', false);
+        params = this.omit(params, 'randomize');
+        [vaultAddress, params] = this.handleOptionAndParams(params, 'createOrder', 'vaultAddress');
+        vaultAddress = this.formatVaultAddress(vaultAddress);
+        const durationMins = Math.floor(duration / 1000 / 60); // convert from ms to minutes
+        const orderObj = {
+            'a': this.parseToInt(market['baseId']),
+            'b': isBuy,
+            's': this.amountToPrecision(symbol, amount),
+            'r': this.safeBool(params, 'reduceOnly', false),
+            'm': durationMins,
+            't': randomize,
+        };
+        const orderAction = {
+            'type': 'twapOrder',
+            'twap': orderObj,
+        };
+        const signature = this.signL1Action(orderAction, nonce, vaultAddress);
+        const request = {
+            'action': orderAction,
+            'nonce': nonce,
+            'signature': signature,
+            // 'vaultAddress': vaultAddress,
+        };
+        if (vaultAddress !== undefined) {
+            params = this.omit(params, 'vaultAddress');
+            request['vaultAddress'] = vaultAddress;
+        }
+        const expiresAfter = this.safeInteger(params, 'expiresAfter');
+        if (expiresAfter !== undefined) {
+            request['expiresAfter'] = expiresAfter;
+            params = this.omit(params, 'expiresAfter');
+        }
+        const response = await this.privatePostExchange(request);
+        // {
+        //     "status":"ok",
+        //     "response":{
+        //         "type":"twapOrder",
+        //         "data":{
+        //             "status": {
+        //                 "running":{
+        //                 "twapId":77738308
+        //                 }
+        //             }
+        //         }
+        //     }
+        // }
+        const responseObj = this.safeDict(response, 'response', {});
+        const data = this.safeDict(responseObj, 'data', {});
+        const status = this.safeDict(data, 'status', {});
+        const running = this.safeDict(status, 'running', {});
+        const orderId = this.safeString(running, 'twapId');
+        return this.parseOrder({ 'status': 'running', 'oid': orderId }, market);
+    }
     /**
      * @method
      * @name hyperliquid#createOrders
@@ -2110,9 +2282,14 @@ export default class hyperliquid extends Exchange {
      * @param {string} [params.clientOrderId] client order id, (optional 128 bit hex string e.g. 0x1234567890abcdef1234567890abcdef)
      * @param {string} [params.vaultAddress] the vault address for order
      * @param {string} [params.subAccountAddress] sub account user address
+     * @param {boolean} [params.twap] whether the order to cancel is a twap order, (default is false)
      * @returns {object} An [order structure]{@link https://docs.ccxt.com/?id=order-structure}
      */
     async cancelOrder(id, symbol = undefined, params = {}) {
+        if (this.safeBool(params, 'twap', false)) {
+            params = this.omit(params, 'twap');
+            return await this.cancelTwapOrder(id, symbol, params);
+        }
         const orders = await this.cancelOrders([id], symbol, params);
         return this.safeDict(orders, 0);
     }
@@ -2165,6 +2342,66 @@ export default class hyperliquid extends Exchange {
         }
         return orders;
     }
+    /**
+     * @method
+     * @name hyperliquid#cancelTwapOrder
+     * @description cancels a running twap order
+     * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#cancel-a-twap-order
+     * @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 {int} [params.expiresAfter] time in ms after which the twap order expires
+     * @param {string} [params.vaultAddress] the vault address for order
+     * @returns {object} An [order structure]{@link https://docs.ccxt.com/?id=order-structure}
+     */
+    async cancelTwapOrder(id, symbol = undefined, params = {}) {
+        await this.loadMarkets();
+        if (symbol === undefined) {
+            throw new ArgumentsRequired(this.id + ' cancelTwapOrder() requires a symbol argument');
+        }
+        const market = this.market(symbol);
+        let vaultAddress = undefined;
+        [vaultAddress, params] = this.handleOptionAndParams(params, 'cancelTwapOrder', 'vaultAddress');
+        vaultAddress = this.formatVaultAddress(vaultAddress);
+        const action = {
+            'type': 'twapCancel',
+            'a': this.parseToInt(market['baseId']),
+            't': this.parseToNumeric(id),
+        };
+        const nonce = this.milliseconds();
+        const signature = this.signL1Action(action, nonce, vaultAddress);
+        const request = {
+            'action': action,
+            'nonce': nonce,
+            'signature': signature,
+            // 'vaultAddress': vaultAddress,
+        };
+        if (vaultAddress !== undefined) {
+            params = this.omit(params, 'vaultAddress');
+            request['vaultAddress'] = vaultAddress;
+        }
+        const expiresAfter = this.safeInteger(params, 'expiresAfter');
+        if (expiresAfter !== undefined) {
+            request['expiresAfter'] = expiresAfter;
+            params = this.omit(params, 'expiresAfter');
+        }
+        const response = await this.privatePostExchange(request);
+        //
+        //  {
+        //     "status":"ok",
+        //     "response":{
+        //        "type":"twapCancel",
+        //        "data":{
+        //           "status": "success"
+        //        }
+        //     }
+        //  }
+        //
+        const responseObj = this.safeDict(response, 'response', {});
+        const data = this.safeDict(responseObj, 'data', {});
+        const status = this.safeString(data, 'status');
+        return this.parseOrder({ 'status': status, 'oid': id }, market);
+    }
     cancelOrdersRequest(ids, symbol = undefined, params = {}) {
         /**
          * @method
@@ -3162,12 +3399,16 @@ export default class hyperliquid extends Exchange {
         if (side !== undefined) {
             side = (side === 'A') ? 'sell' : 'buy';
         }
-        const fee = this.safeString(trade, 'fee');
+        let fee = this.safeString(trade, 'fee');
         let takerOrMaker = undefined;
         const crossed = this.safeBool(trade, 'crossed');
         if (crossed !== undefined) {
             takerOrMaker = crossed ? 'taker' : 'maker';
         }
+        const builderFee = this.safeString(trade, 'builderFee');
+        if (builderFee !== undefined) {
+            fee = Precise.stringAdd(fee, builderFee);
+        }
         return this.safeTrade({
             'info': trade,
             'timestamp': timestamp,
@@ -4445,6 +4686,13 @@ export default class hyperliquid extends Exchange {
                     break;
                 }
             }
+            if ('status' in data) {
+                const errorStatus = this.safeDict(data, 'status', {});
+                const errorMsg = this.safeString(errorStatus, 'error');
+                if (errorStatus !== undefined) {
+                    message = errorMsg;
+                }
+            }
         }
         const feedback = this.id + ' ' + body;
         const nonEmptyMessage = ((message !== undefined) && (message !== ''));

package/js/src/krakenfutures.js

@@ -1681,7 +1681,9 @@ export default class krakenfutures extends Exchange {
             'filled': 'closed',
             'notFound': 'rejected',
             'untouched': 'open',
-            'partiallyFilled': 'open', // the size of the order is partially but not entirely filled
+            'partiallyFilled': 'open',
+            'ENTERED_BOOK': 'open',
+            'FULLY_EXECUTED': 'closed',
         };
         return this.safeString(statuses, status, status);
     }
@@ -1920,6 +1922,72 @@ export default class krakenfutures extends Exchange {
         //     status: 'closed'
         //   }
         //
+        // order: {
+        //     type: 'ORDER',
+        //     orderId: 'a111f276-95fd-47fc-b77b-709c5ab2e9e1',
+        //     cliOrdId: null,
+        //     symbol: 'PF_LTCUSD',
+        //     side: 'buy',
+        //     quantity: '0.1',
+        //     filled: '0',
+        //     limitPrice: '40',
+        //     reduceOnly: false,
+        //     timestamp: '2026-02-13T12:09:03.738Z',
+        //     lastUpdateTimestamp: '2026-02-13T12:09:03.738Z'
+        // },
+        //     status: 'ENTERED_BOOK',
+        //     updateReason: null,
+        //     error: null
+        // }
+        //
+        const orderDictFromFetchOrder = this.safeDict(order, 'order');
+        if (orderDictFromFetchOrder !== undefined) {
+            // order: {
+            //     type: 'ORDER',
+            //     orderId: 'a111f276-95fd-47fc-b77b-709c5ab2e9e1',
+            //     cliOrdId: null,
+            //     symbol: 'PF_LTCUSD',
+            //     side: 'buy',
+            //     quantity: '0.1',
+            //     filled: '0',
+            //     limitPrice: '40',
+            //     reduceOnly: false,
+            //     timestamp: '2026-02-13T12:09:03.738Z',
+            //     lastUpdateTimestamp: '2026-02-13T12:09:03.738Z'
+            // },
+            //     status: 'ENTERED_BOOK',
+            //     updateReason: null,
+            //     error: null
+            //
+            const datetime = this.safeString(orderDictFromFetchOrder, 'timestamp');
+            const innerStatus = this.safeString(order, 'status');
+            return this.safeOrder({
+                'info': order,
+                'id': this.safeString(orderDictFromFetchOrder, 'orderId'),
+                'clientOrderId': this.safeStringN(orderDictFromFetchOrder, ['cliOrdId']),
+                'timestamp': this.parse8601(datetime),
+                'datetime': datetime,
+                'lastTradeTimestamp': undefined,
+                'lastUpdateTimestamp': this.parse8601(this.safeString(orderDictFromFetchOrder, 'lastUpdateTimestamp')),
+                'symbol': this.safeSymbol(this.safeString(orderDictFromFetchOrder, 'symbol'), market),
+                'type': undefined,
+                'timeInForce': undefined,
+                'postOnly': undefined,
+                'reduceOnly': this.safeBool(orderDictFromFetchOrder, 'reduceOnly'),
+                'side': this.safeString(orderDictFromFetchOrder, 'side'),
+                'price': this.safeString(orderDictFromFetchOrder, 'limitPrice'),
+                'triggerPrice': undefined,
+                'amount': this.safeString(orderDictFromFetchOrder, 'quantity'),
+                'cost': undefined,
+                'average': undefined,
+                'filled': this.safeString(orderDictFromFetchOrder, 'filled'),
+                'remaining': undefined,
+                'status': this.parseOrderStatus(innerStatus),
+                'fee': undefined,
+                'fees': undefined,
+                'trades': undefined,
+            });
+        }
         const orderEvents = this.safeValue(order, 'orderEvents', []);
         const errorStatus = this.safeString(order, 'status');
         const orderEventsLength = orderEvents.length;
@@ -2390,7 +2458,7 @@ export default class krakenfutures extends Exchange {
         //         "fundingRate": -0.000000756414717067,
         //         "fundingRatePrediction": 0.000000195218676,
         //         "suspended": false,
-        //         "indexPrice": 0.043392,
+        //         "indexPrice": 0.043391,
         //         "postOnly": false,
         //         "change24h": -0.46
         //     }
@@ -2403,16 +2471,16 @@ export default class krakenfutures extends Exchange {
         let fundingRateResult = Precise.stringDiv(fundingRateString, markPriceString);
         const nextFundingRateString = this.safeString(ticker, 'fundingRatePrediction');
         let nextFundingRateResult = Precise.stringDiv(nextFundingRateString, markPriceString);
-        if (fundingRateResult > '0.25') {
+        if (Precise.stringGt(fundingRateResult, '0.25')) {
             fundingRateResult = '0.25';
         }
-        else if (fundingRateResult > '-0.25') {
+        else if (Precise.stringLt(fundingRateResult, '-0.25')) {
             fundingRateResult = '-0.25';
         }
-        if (nextFundingRateResult > '0.25') {
+        if (Precise.stringGt(nextFundingRateResult, '0.25')) {
             nextFundingRateResult = '0.25';
         }
-        else if (nextFundingRateResult > '-0.25') {
+        else if (Precise.stringLt(nextFundingRateResult, '-0.25')) {
             nextFundingRateResult = '-0.25';
         }
         return {

package/js/src/kucoin.js

@@ -129,6 +129,7 @@ export default class kucoin extends Exchange {
                     'broker': 'https://api-broker.kucoin.com',
                     'earn': 'https://api.kucoin.com',
                     'uta': 'https://api.kucoin.com',
+                    'utaPrivate': 'https://api.kucoin.com',
                 },
                 'www': 'https://www.kucoin.com',
                 'doc': [
@@ -485,17 +486,55 @@ export default class kucoin extends Exchange {
                     'get': {
                         'market/announcement': 20,
                         'market/currency': 3,
+                        'market/currencies': 3,
                         'market/instrument': 4,
                         'market/ticker': 15,
-                        'market/orderbook': 3,
                         'market/trade': 3,
                         'market/kline': 3,
                         'market/funding-rate': 2,
                         'market/funding-rate-history': 5,
                         'market/cross-config': 25,
+                        'market/collateral-discount-ratio': 10,
+                        'market/index-price': 20,
+                        'market/position-tiers': 20,
+                        'market/open-interest': 10,
                         'server/status': 3,
                     },
                 },
+                'utaPrivate': {
+                    'get': {
+                        'market/orderbook': 3,
+                        'account/balance': 5,
+                        'account/transfer-quota': 20,
+                        'account/mode': 30,
+                        'account/ledger': 2,
+                        'account/interest-history': 15,
+                        'account/deposit/address': 5,
+                        '{accountMode}/account/balance': 5,
+                        '{accountMode}/account/overview': 5,
+                        '{accountMode}/order/detail': 4,
+                        '{accountMode}/order/open-list': 4,
+                        '{accountMode}/order/history': 4,
+                        '{accountMode}/order/execution': 4,
+                        '{accountMode}/position/open-list': 3,
+                        '{accountMode}/position/history': 2,
+                        '{accountMode}/position/tiers': 20,
+                        'sub-account/balance': 5,
+                        'user/fee-rate': 3,
+                        'dcp/query': 2,
+                    },
+                    'post': {
+                        'account/transfer': 4,
+                        'account/mode': 30,
+                        '{accountMode}/account/modify-leverage': 20,
+                        '{accountMode}/order/place': 1,
+                        '{accountMode}/order/place-batch': 4,
+                        '{accountMode}/order/cancel': 1,
+                        '{accountMode}/order/cancel-batch': 4,
+                        'sub-account/canTransferOut': 5,
+                        'dcp/set': 2,
+                    },
+                },
             },
             'timeframes': {
                 '1m': '1min',
@@ -2580,7 +2619,7 @@ export default class kucoin extends Exchange {
             else {
                 request['tradeType'] = 'FUTURES';
             }
-            response = await this.utaGetMarketOrderbook(this.extend(request, params));
+            response = await this.utaPrivateGetMarketOrderbook(this.extend(request, params));
             //
             //     {
             //         "code": "200000",
@@ -5758,9 +5797,9 @@ export default class kucoin extends Exchange {
             endpoint = '/api/v1/' + this.implodeParams(path, params);
         }
         let isUtaPrivate = false;
-        if (api === 'uta') {
+        if ((api === 'uta') || (api === 'utaPrivate')) {
             endpoint = '/api/ua/v1/' + this.implodeParams(path, params);
-            if (path === 'market/orderbook') {
+            if (api === 'utaPrivate') {
                 isUtaPrivate = true;
             }
         }

package/js/src/mexc.js

@@ -153,8 +153,8 @@ export default class mexc extends Exchange {
                         'private': 'https://www.mexc.com/open/api/v2',
                     },
                     'contract': {
-                        'public': 'https://contract.mexc.com/api/v1/contract',
-                        'private': 'https://contract.mexc.com/api/v1/private',
+                        'public': 'https://api.mexc.com/api/v1/contract',
+                        'private': 'https://api.mexc.com/api/v1/private',
                     },
                     'broker': {
                         'private': 'https://api.mexc.com/api/v3/broker',

package/js/src/pro/aster.js

@@ -779,10 +779,19 @@ export default class aster extends asterRest {
         //         "ss": 0
         //     }
         //
+        const e = this.safeString(trade, 'e');
+        const isPublicTrade = (e === 'trade') || (e === 'aggTrade');
         const id = this.safeString2(trade, 't', 'a');
         const timestamp = this.safeInteger(trade, 'T');
         const price = this.safeString2(trade, 'L', 'p');
-        const amount = this.safeString2(trade, 'q', 'l');
+        let amount = undefined;
+        if (isPublicTrade) {
+            amount = this.safeString(trade, 'q');
+        }
+        else {
+            // private trades, amount is in 'l' field, quantity of the last filled trade
+            amount = this.safeString(trade, 'l');
+        }
         let cost = this.safeString(trade, 'Y');
         if (cost === undefined) {
             if ((price !== undefined) && (amount !== undefined)) {
@@ -1712,7 +1721,7 @@ export default class aster extends asterRest {
             const myTrades = this.myTrades;
             myTrades.append(trade);
             client.resolve(this.myTrades, messageHash);
-            const messageHashSymbol = messageHash + ':' + symbol;
+            const messageHashSymbol = messageHash + '::' + symbol;
             client.resolve(this.myTrades, messageHashSymbol);
         }
     }

package/js/src/pro/binance.js

@@ -353,7 +353,8 @@ export default class binance extends binanceRest {
         const symbol = market['symbol'];
         const liquidation = this.parseWsLiquidation(rawLiquidation, market);
         if (this.liquidations === undefined) {
-            this.liquidations = new ArrayCacheBySymbolBySide();
+            const limit = this.safeInteger(this.options, 'liquidationsLimit', 1000);
+            this.liquidations = new ArrayCache(limit);
         }
         const cache = this.liquidations;
         cache.append(liquidation);
@@ -563,7 +564,8 @@ export default class binance extends binanceRest {
         const liquidation = this.parseWsLiquidation(message, market);
         let cache = this.myLiquidations;
         if (cache === undefined) {
-            cache = new ArrayCacheBySymbolBySide();
+            const limit = this.safeInteger(this.options, 'myLiquidationsLimit', 1000);
+            cache = new ArrayCache(limit);
         }
         cache.append(liquidation);
         this.myLiquidations = cache;

package/js/src/pro/bitmex.js

@@ -443,7 +443,8 @@ export default class bitmex extends bitmexRest {
         const rawLiquidations = this.safeValue(message, 'data', []);
         const newLiquidations = [];
         if (this.liquidations === undefined) {
-            this.liquidations = new ArrayCacheBySymbolBySide();
+            const limit = this.safeInteger(this.options, 'liquidationsLimit', 1000);
+            this.liquidations = new ArrayCache(limit);
         }
         const cache = this.liquidations;
         for (let i = 0; i < rawLiquidations.length; i++) {

package/js/src/pro/bybit.js

@@ -1697,7 +1697,8 @@ export default class bybit extends bybitRest {
                 const symbol = market['symbol'];
                 const liquidation = this.parseWsLiquidation(rawLiquidation, market);
                 if (this.liquidations === undefined) {
-                    this.liquidations = new ArrayCacheBySymbolBySide();
+                    const limit = this.safeInteger(this.options, 'liquidationsLimit', 1000);
+                    this.liquidations = new ArrayCache(limit);
                 }
                 const cache = this.liquidations;
                 cache.append(liquidation);
@@ -1712,7 +1713,8 @@ export default class bybit extends bybitRest {
             const symbol = market['symbol'];
             const liquidation = this.parseWsLiquidation(rawLiquidation, market);
             if (this.liquidations === undefined) {
-                this.liquidations = new ArrayCacheBySymbolBySide();
+                const limit = this.safeInteger(this.options, 'liquidationsLimit', 1000);
+                this.liquidations = new ArrayCache(limit);
             }
             const cache = this.liquidations;
             cache.append(liquidation);

package/js/src/pro/gate.js

@@ -1525,7 +1525,8 @@ export default class gate extends gateRest {
         const rawLiquidations = this.safeList(message, 'result', []);
         const newLiquidations = [];
         if (this.liquidations === undefined) {
-            this.liquidations = new ArrayCacheBySymbolBySide();
+            const limit = this.safeInteger(this.options, 'liquidationsLimit', 1000);
+            this.liquidations = new ArrayCache(limit);
         }
         const cache = this.liquidations;
         for (let i = 0; i < rawLiquidations.length; i++) {