ccxt 4.5.35 → 4.5.37

package/dist/cjs/src/hyperliquid.js

@@ -213,6 +213,9 @@ class hyperliquid extends hyperliquid$1["default"] {
                     'Insufficient spot balance asset': errors.InsufficientFunds,
                     'Insufficient balance for withdrawal': errors.InsufficientFunds,
                     'Insufficient balance for token transfer': errors.InsufficientFunds,
+                    'TWAP order value too small. Min is $1200, which is $10 per minute.': errors.InvalidOrder,
+                    'TWAP was never placed, already canceled, or filled.': errors.OrderNotFound,
+                    'Too many cumulative requests sent': errors.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': number.TICK_SIZE,
@@ -1708,6 +1711,17 @@ class hyperliquid extends hyperliquid$1["default"] {
         };
         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': [
@@ -1808,11 +1822,70 @@ class hyperliquid extends hyperliquid$1["default"] {
         }
         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,
@@ -1826,7 +1899,7 @@ class hyperliquid extends hyperliquid$1["default"] {
             'enabled': payload['enabled'],
             'user': payload['user'],
             'nonce': nonce,
-            'type': 'userDexAbstraction',
+            'type': type,
         };
         const request = {
             'action': action,
@@ -1844,6 +1917,29 @@ class hyperliquid extends hyperliquid$1["default"] {
         //
         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
@@ -1871,6 +1967,82 @@ class hyperliquid extends hyperliquid$1["default"] {
         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
@@ -2109,9 +2281,14 @@ class hyperliquid extends hyperliquid$1["default"] {
      * @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);
     }
@@ -2164,6 +2341,66 @@ class hyperliquid extends hyperliquid$1["default"] {
         }
         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 errors.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
@@ -4444,6 +4681,13 @@ class hyperliquid extends hyperliquid$1["default"] {
                     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/dist/cjs/src/krakenfutures.js

@@ -2389,7 +2389,7 @@ class krakenfutures extends krakenfutures$1["default"] {
         //         "fundingRate": -0.000000756414717067,
         //         "fundingRatePrediction": 0.000000195218676,
         //         "suspended": false,
-        //         "indexPrice": 0.043392,
+        //         "indexPrice": 0.043391,
         //         "postOnly": false,
         //         "change24h": -0.46
         //     }
@@ -2402,16 +2402,16 @@ class krakenfutures extends krakenfutures$1["default"] {
         let fundingRateResult = Precise["default"].stringDiv(fundingRateString, markPriceString);
         const nextFundingRateString = this.safeString(ticker, 'fundingRatePrediction');
         let nextFundingRateResult = Precise["default"].stringDiv(nextFundingRateString, markPriceString);
-        if (fundingRateResult > '0.25') {
+        if (Precise["default"].stringGt(fundingRateResult, '0.25')) {
             fundingRateResult = '0.25';
         }
-        else if (fundingRateResult > '-0.25') {
+        else if (Precise["default"].stringLt(fundingRateResult, '-0.25')) {
             fundingRateResult = '-0.25';
         }
-        if (nextFundingRateResult > '0.25') {
+        if (Precise["default"].stringGt(nextFundingRateResult, '0.25')) {
             nextFundingRateResult = '0.25';
         }
-        else if (nextFundingRateResult > '-0.25') {
+        else if (Precise["default"].stringLt(nextFundingRateResult, '-0.25')) {
             nextFundingRateResult = '-0.25';
         }
         return {
@@ -2692,7 +2692,7 @@ class krakenfutures extends krakenfutures$1["default"] {
         for (let i = 0; i < marginLevels.length; i++) {
             const tier = marginLevels[i];
             const initialMargin = this.safeString(tier, 'initialMargin');
-            const minNotional = this.safeNumber(tier, 'numNonContractUnits');
+            const minNotional = this.safeNumber2(tier, 'numNonContractUnits', 'contracts');
             if (i !== 0) {
                 const tiersLength = tiers.length;
                 const previousTier = tiers[tiersLength - 1];

package/dist/cjs/src/kucoin.js

@@ -128,6 +128,7 @@ class kucoin extends kucoin$1["default"] {
                     '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': [
@@ -484,17 +485,55 @@ class kucoin extends kucoin$1["default"] {
                     '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',
@@ -2579,7 +2618,7 @@ class kucoin extends kucoin$1["default"] {
             else {
                 request['tradeType'] = 'FUTURES';
             }
-            response = await this.utaGetMarketOrderbook(this.extend(request, params));
+            response = await this.utaPrivateGetMarketOrderbook(this.extend(request, params));
             //
             //     {
             //         "code": "200000",
@@ -5757,9 +5796,9 @@ class kucoin extends kucoin$1["default"] {
             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/dist/cjs/src/mexc.js

@@ -152,8 +152,8 @@ class mexc extends mexc$1["default"] {
                         '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/dist/cjs/src/pro/aster.js

@@ -1480,23 +1480,26 @@ class aster extends aster$1["default"] {
         //     }
         //
         const messageHash = 'positions';
+        if (this.positions === undefined) {
+            this.positions = new Cache.ArrayCacheBySymbolBySide();
+        }
+        const cache = this.positions;
+        const data = this.safeDict(message, 'a', {});
+        const rawPositions = this.safeList(data, 'P', []);
+        const newPositions = [];
+        for (let i = 0; i < rawPositions.length; i++) {
+            const rawPosition = rawPositions[i];
+            const position = this.parseWsPosition(rawPosition);
+            const timestamp = this.safeInteger(message, 'E');
+            position['timestamp'] = timestamp;
+            position['datetime'] = this.iso8601(timestamp);
+            newPositions.push(position);
+            cache.append(position);
+        }
         const messageHashes = this.findMessageHashes(client, messageHash);
         if (!this.isEmpty(messageHashes)) {
-            if (this.positions === undefined) {
-                this.positions = new Cache.ArrayCacheBySymbolBySide();
-            }
-            const cache = this.positions;
-            const data = this.safeDict(message, 'a', {});
-            const rawPositions = this.safeList(data, 'P', []);
-            const newPositions = [];
-            for (let i = 0; i < rawPositions.length; i++) {
-                const rawPosition = rawPositions[i];
-                const position = this.parseWsPosition(rawPosition);
-                const timestamp = this.safeInteger(message, 'E');
-                position['timestamp'] = timestamp;
-                position['datetime'] = this.iso8601(timestamp);
-                newPositions.push(position);
-                cache.append(position);
+            for (let i = 0; i < newPositions.length; i++) {
+                const position = newPositions[i];
                 const symbol = position['symbol'];
                 const symbolMessageHash = messageHash + '::' + symbol;
                 client.resolve(position, symbolMessageHash);
@@ -1788,18 +1791,18 @@ class aster extends aster$1["default"] {
         //     }
         //
         const messageHash = 'orders';
+        const market = this.getMarketFromOrder(client, message);
+        if (this.orders === undefined) {
+            const limit = this.safeInteger(this.options, 'ordersLimit', 1000);
+            this.orders = new Cache.ArrayCacheBySymbolById(limit);
+        }
+        const cache = this.orders;
+        const parsed = this.parseWsOrder(message, market);
+        const symbol = market['symbol'];
+        cache.append(parsed);
         const messageHashes = this.findMessageHashes(client, messageHash);
         if (!this.isEmpty(messageHashes)) {
-            const market = this.getMarketFromOrder(client, message);
-            if (this.orders === undefined) {
-                const limit = this.safeInteger(this.options, 'ordersLimit', 1000);
-                this.orders = new Cache.ArrayCacheBySymbolById(limit);
-            }
-            const cache = this.orders;
-            const parsed = this.parseWsOrder(message, market);
-            const symbol = market['symbol'];
             const symbolMessageHash = messageHash + '::' + symbol;
-            cache.append(parsed);
             client.resolve(cache, symbolMessageHash);
             client.resolve(cache, messageHash);
         }

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

@@ -351,13 +351,11 @@ class binance extends binance$1["default"] {
         const market = this.safeMarket(marketId, undefined, '', 'contract');
         const symbol = market['symbol'];
         const liquidation = this.parseWsLiquidation(rawLiquidation, market);
-        let liquidations = this.safeValue(this.liquidations, symbol);
-        if (liquidations === undefined) {
-            const limit = this.safeInteger(this.options, 'liquidationsLimit', 1000);
-            liquidations = new Cache.ArrayCache(limit);
+        if (this.liquidations === undefined) {
+            this.liquidations = new Cache.ArrayCacheBySymbolBySide();
         }
-        liquidations.append(liquidation);
-        this.liquidations[symbol] = liquidations;
+        const cache = this.liquidations;
+        cache.append(liquidation);
         client.resolve([liquidation], 'liquidations');
         client.resolve([liquidation], 'liquidations::' + symbol);
     }
@@ -562,13 +560,12 @@ class binance extends binance$1["default"] {
         const market = this.safeMarket(marketId, undefined, undefined, 'swap');
         const symbol = this.safeSymbol(marketId, market);
         const liquidation = this.parseWsLiquidation(message, market);
-        let myLiquidations = this.safeValue(this.myLiquidations, symbol);
-        if (myLiquidations === undefined) {
-            const limit = this.safeInteger(this.options, 'myLiquidationsLimit', 1000);
-            myLiquidations = new Cache.ArrayCache(limit);
+        let cache = this.myLiquidations;
+        if (cache === undefined) {
+            cache = new Cache.ArrayCacheBySymbolBySide();
         }
-        myLiquidations.append(liquidation);
-        this.myLiquidations[symbol] = myLiquidations;
+        cache.append(liquidation);
+        this.myLiquidations = cache;
         client.resolve([liquidation], 'myLiquidations');
         client.resolve([liquidation], 'myLiquidations::' + symbol);
     }

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

@@ -439,17 +439,14 @@ class bitmex extends bitmex$1["default"] {
         //
         const rawLiquidations = this.safeValue(message, 'data', []);
         const newLiquidations = [];
+        if (this.liquidations === undefined) {
+            this.liquidations = new Cache.ArrayCacheBySymbolBySide();
+        }
+        const cache = this.liquidations;
         for (let i = 0; i < rawLiquidations.length; i++) {
             const rawLiquidation = rawLiquidations[i];
             const liquidation = this.parseLiquidation(rawLiquidation);
-            const symbol = liquidation['symbol'];
-            let liquidations = this.safeValue(this.liquidations, symbol);
-            if (liquidations === undefined) {
-                const limit = this.safeInteger(this.options, 'liquidationsLimit', 1000);
-                liquidations = new Cache.ArrayCache(limit);
-            }
-            liquidations.append(liquidation);
-            this.liquidations[symbol] = liquidations;
+            cache.append(liquidation);
             newLiquidations.push(liquidation);
         }
         client.resolve(newLiquidations, 'liquidations');

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

@@ -1695,13 +1695,11 @@ class bybit extends bybit$1["default"] {
                 const market = this.safeMarket(marketId, undefined, '', 'contract');
                 const symbol = market['symbol'];
                 const liquidation = this.parseWsLiquidation(rawLiquidation, market);
-                let liquidations = this.safeValue(this.liquidations, symbol);
-                if (liquidations === undefined) {
-                    const limit = this.safeInteger(this.options, 'liquidationsLimit', 1000);
-                    liquidations = new Cache.ArrayCache(limit);
+                if (this.liquidations === undefined) {
+                    this.liquidations = new Cache.ArrayCacheBySymbolBySide();
                 }
-                liquidations.append(liquidation);
-                this.liquidations[symbol] = liquidations;
+                const cache = this.liquidations;
+                cache.append(liquidation);
                 client.resolve([liquidation], 'liquidations');
                 client.resolve([liquidation], 'liquidations::' + symbol);
             }
@@ -1712,13 +1710,11 @@ class bybit extends bybit$1["default"] {
             const market = this.safeMarket(marketId, undefined, '', 'contract');
             const symbol = market['symbol'];
             const liquidation = this.parseWsLiquidation(rawLiquidation, market);
-            let liquidations = this.safeValue(this.liquidations, symbol);
-            if (liquidations === undefined) {
-                const limit = this.safeInteger(this.options, 'liquidationsLimit', 1000);
-                liquidations = new Cache.ArrayCache(limit);
+            if (this.liquidations === undefined) {
+                this.liquidations = new Cache.ArrayCacheBySymbolBySide();
             }
-            liquidations.append(liquidation);
-            this.liquidations[symbol] = liquidations;
+            const cache = this.liquidations;
+            cache.append(liquidation);
             client.resolve([liquidation], 'liquidations');
             client.resolve([liquidation], 'liquidations::' + symbol);
         }