ccxt 4.5.35 → 4.5.36

package/js/src/base/Exchange.js

@@ -95,7 +95,7 @@ export default class Exchange {
         this.verbose = false;
         this.twofa = undefined; // two-factor authentication (2-FA)
         this.balance = {};
-        this.liquidations = {};
+        this.liquidations = undefined;
         this.orderbooks = {};
         this.tickers = {};
         this.fundingRates = {};
@@ -103,7 +103,7 @@ export default class Exchange {
         this.orders = undefined;
         this.triggerOrders = undefined;
         this.transactions = {};
-        this.myLiquidations = {};
+        this.myLiquidations = undefined;
         this.requiresWeb3 = false;
         this.requiresEddsa = false;
         this.precision = undefined;
@@ -313,12 +313,12 @@ export default class Exchange {
         this.bidsasks = {};
         this.orderbooks = {};
         this.tickers = {};
-        this.liquidations = {};
+        this.liquidations = undefined;
         this.orders = undefined;
         this.trades = {};
         this.transactions = {};
         this.ohlcvs = {};
-        this.myLiquidations = {};
+        this.myLiquidations = undefined;
         this.myTrades = undefined;
         this.positions = undefined;
         // web3 and cryptography flags

package/js/src/base/functions/generic.d.ts

@@ -24,6 +24,6 @@ declare const flatten: (x: any[], out?: any[]) => any[];
 declare const pluck: (x: Dictionary<any>, k: any) => any[];
 declare const omit: (x: Dictionary<any>, ...args: any) => any;
 declare const sum: (...xs: any[]) => any;
-declare const deepExtend: (...xs: any) => any;
+declare const deepExtend: (...args: any) => any;
 declare const merge: (target: Dictionary<any>, ...args: any) => Dictionary<any>;
 export { keys, values, extend, clone, index, ordered, unique, arrayConcat, inArray, toArray, isEmpty, sort, keysort, indexBy, groupBy, filterBy, sortBy, sortBy2, flatten, pluck, omit, sum, deepExtend, merge, };

package/js/src/base/functions/generic.js

@@ -5,7 +5,7 @@
 // EDIT THE CORRESPONDENT .ts FILE INSTEAD
 
 // ----------------------------------------------------------------------------
-import { isNumber, isDictionary, isArray } from './type.js';
+import { isNumber, isArray } from './type.js';
 // ----------------------------------------------------------------------------
 const keys = Object.keys; // eslint-disable-line padding-line-between-statements
 const values = (x) => ((!isArray(x)) ? Object.values(x) : x); // don't copy arrays if they're already arrays
@@ -142,22 +142,39 @@ const sum = (...xs) => {
     const ns = xs.filter(isNumber); // leave only numbers
     return (ns.length > 0) ? ns.reduce((a, b) => a + b, 0) : undefined;
 };
-const deepExtend = function deepExtend(...xs) {
-    let out = undefined;
-    for (const x of xs) {
-        if (isDictionary(x)) {
-            if (!isDictionary(out)) {
-                out = {};
+const deepExtend = function (...args) {
+    let result = null;
+    let resultIsObject = false;
+    for (const arg of args) {
+        if (arg !== null && typeof arg === 'object' && arg.constructor === Object) {
+            // This is a plain object (even if empty) so set the return type.
+            if (result === null || !resultIsObject) {
+                result = {};
+                resultIsObject = true;
             }
-            for (const k in x) {
-                out[k] = deepExtend(out[k], x[k]);
+            // Skip actual merging if object is empty.
+            if (Object.keys(arg).length === 0) {
+                continue;
+            }
+            for (const key in arg) {
+                const value = arg[key];
+                const current = result[key];
+                if (current !== null && typeof current === 'object' && current.constructor === Object &&
+                    value !== null && typeof value === 'object' && value.constructor === Object) {
+                    result[key] = deepExtend(current, value);
+                }
+                else {
+                    result[key] = value;
+                }
             }
         }
         else {
-            out = x;
+            // arg is null or other non-object.
+            result = arg;
+            resultIsObject = false;
         }
     }
-    return out;
+    return result;
 };
 const merge = (target, ...args) => {
     // doesn't overwrite defined keys with undefined

package/js/src/base/functions/time.d.ts

@@ -10,7 +10,6 @@ declare class TimedOut extends Error {
 declare const iso8601: (timestamp: any) => string;
 declare const parse8601: (x: any) => number;
 declare const parseDate: (x: any) => number;
-declare const rfc2616: (timestamp?: any) => string;
 declare const mdy: (timestamp: any, infix?: string) => string;
 declare const ymd: (timestamp: any, infix: any, fullYear?: boolean) => string;
 declare const yymmdd: (timestamp: any, infix?: string) => string;
@@ -18,4 +17,4 @@ declare const yyyymmdd: (timestamp: any, infix?: string) => string;
 declare const ymdhms: (timestamp: any, infix?: string) => string;
 declare const sleep: (ms: any) => Promise<unknown>;
 declare const timeout: (ms: any, promise: any) => Promise<any>;
-export { now, microseconds, milliseconds, seconds, iso8601, parse8601, rfc2616, uuidv1, parseDate, mdy, ymd, yymmdd, yyyymmdd, ymdhms, setTimeout_safe, sleep, TimedOut, timeout, };
+export { now, microseconds, milliseconds, seconds, iso8601, parse8601, uuidv1, parseDate, mdy, ymd, yymmdd, yyyymmdd, ymdhms, setTimeout_safe, sleep, TimedOut, timeout, };

package/js/src/base/functions/time.js

@@ -115,7 +115,6 @@ const parseDate = (x) => {
     }
     return parse8601(x);
 };
-const rfc2616 = (timestamp = undefined) => new Date(timestamp).toUTCString();
 const mdy = (timestamp, infix = '-') => {
     infix = infix || '';
     const date = new Date(timestamp);
@@ -168,4 +167,4 @@ const timeout = async (ms, promise) => {
         clear(); // fixes https://github.com/ccxt/ccxt/issues/749
     }
 };
-export { now, microseconds, milliseconds, seconds, iso8601, parse8601, rfc2616, uuidv1, parseDate, mdy, ymd, yymmdd, yyyymmdd, ymdhms, setTimeout_safe, sleep, TimedOut, timeout, };
+export { now, microseconds, milliseconds, seconds, iso8601, parse8601, uuidv1, parseDate, mdy, ymd, yymmdd, yyyymmdd, ymdhms, setTimeout_safe, sleep, TimedOut, timeout, };

package/js/src/bybit.js

@@ -350,7 +350,7 @@ export default class bybit extends Exchange {
                         'v5/asset/coin-greeks': 1,
                         'v5/account/fee-rate': 10,
                         'v5/account/info': 5,
-                        'v5/account/transaction-log': 1,
+                        'v5/account/transaction-log': 1.66,
                         'v5/account/contract-transaction-log': 1,
                         'v5/account/smp-group': 1,
                         'v5/account/mmp-state': 5,
@@ -4187,11 +4187,16 @@ export default class bybit extends Exchange {
                         }
                     }
                 }
-                if (tpslModeSl !== tpslModeTp) {
+                if (isTakeProfitOrder && isStopLossOrder && tpslModeSl !== tpslModeTp) {
                     throw new InvalidOrder(this.id + ' createOrder() requires both stopLoss and takeProfit to be full or partial when using as OCO combination');
                 }
-                request['tpslMode'] = tpslModeSl; // same as tpslModeTp
-                params = this.omit(params, ['stopLossLimitPrice', 'takeProfitLimitPrice']);
+                if (tpslModeSl !== undefined) {
+                    request['tpslMode'] = tpslModeSl;
+                }
+                else {
+                    request['tpslMode'] = tpslModeTp;
+                }
+                params = this.omit(params, ['stopLossLimitPrice', 'takeProfitLimitPrice', 'tradingStopEndpoint']);
             }
         }
         else {

package/js/src/coinbase.d.ts

@@ -251,6 +251,7 @@ export default class coinbase extends Exchange {
      * @param {string} [params.retail_portfolio_id] portfolio uid
      * @param {boolean} [params.is_max] Used in conjunction with tradable_balance to indicate the user wants to use their entire tradable balance
      * @param {string} [params.tradable_balance] amount of tradable balance
+     * @param {float} [params.reduceOnly] set to true for closing a position or use closePosition
      * @returns {object} an [order structure]{@link https://docs.ccxt.com/?id=order-structure}
      */
     createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
@@ -439,6 +440,7 @@ export default class coinbase extends Exchange {
      * @param {string} [tag] an optional tag for the withdrawal
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @param {string} [params.network] the cryptocurrency network to use for the withdrawal using the lowercase name like bitcoin, ethereum, solana, etc.
+     * @param {object} [params.travel_rule_data] some regions require travel rule information for crypto withdrawals, see the exchange docs for details https://docs.cdp.coinbase.com/coinbase-app/transfer-apis/travel-rule
      * @returns {object} a [transaction structure]{@link https://docs.ccxt.com/?id=transaction-structure}
      */
     withdraw(code: string, amount: number, address: string, tag?: Str, params?: {}): Promise<Transaction>;

package/js/src/coinbase.js

@@ -2978,6 +2978,7 @@ export default class coinbase extends Exchange {
      * @param {string} [params.retail_portfolio_id] portfolio uid
      * @param {boolean} [params.is_max] Used in conjunction with tradable_balance to indicate the user wants to use their entire tradable balance
      * @param {string} [params.tradable_balance] amount of tradable balance
+     * @param {float} [params.reduceOnly] set to true for closing a position or use closePosition
      * @returns {object} an [order structure]{@link https://docs.ccxt.com/?id=order-structure}
      */
     async createOrder(symbol, type, side, amount, price = undefined, params = {}) {
@@ -2989,6 +2990,12 @@ export default class coinbase extends Exchange {
             'product_id': market['id'],
             'side': side.toUpperCase(),
         };
+        const reduceOnly = this.safeBool(params, 'reduceOnly');
+        if (reduceOnly) {
+            params = this.omit(params, 'reduceOnly');
+            params['amount'] = amount;
+            return await this.closePosition(symbol, side, params);
+        }
         const triggerPrice = this.safeNumberN(params, ['stopPrice', 'stop_price', 'triggerPrice']);
         const stopLossPrice = this.safeNumber(params, 'stopLossPrice');
         const takeProfitPrice = this.safeNumber(params, 'takeProfitPrice');
@@ -4102,6 +4109,7 @@ export default class coinbase extends Exchange {
      * @param {string} [tag] an optional tag for the withdrawal
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @param {string} [params.network] the cryptocurrency network to use for the withdrawal using the lowercase name like bitcoin, ethereum, solana, etc.
+     * @param {object} [params.travel_rule_data] some regions require travel rule information for crypto withdrawals, see the exchange docs for details https://docs.cdp.coinbase.com/coinbase-app/transfer-apis/travel-rule
      * @returns {object} a [transaction structure]{@link https://docs.ccxt.com/?id=transaction-structure}
      */
     async withdraw(code, amount, address, tag = undefined, params = {}) {
@@ -4109,6 +4117,12 @@ export default class coinbase extends Exchange {
         this.checkAddress(address);
         await this.loadMarkets();
         const currency = this.currency(code);
+        const request = {
+            'type': 'send',
+            'to': address,
+            'amount': this.numberToString(amount),
+            'currency': currency['id'],
+        };
         let accountId = this.safeString2(params, 'account_id', 'accountId');
         params = this.omit(params, ['account_id', 'accountId']);
         if (accountId === undefined) {
@@ -4119,14 +4133,11 @@ export default class coinbase extends Exchange {
             if (accountId === undefined) {
                 throw new ExchangeError(this.id + ' withdraw() could not find account id for ' + code);
             }
+            request['account_id'] = accountId;
+        }
+        else {
+            request['account_id'] = accountId;
         }
-        const request = {
-            'account_id': accountId,
-            'type': 'send',
-            'to': address,
-            'amount': amount,
-            'currency': currency['id'],
-        };
         if (tag !== undefined) {
             request['destination_tag'] = tag;
         }

package/js/src/coinex.js

@@ -421,6 +421,8 @@ export default class coinex extends Exchange {
                             'futures/stop-order': 20,
                             'futures/batch-order': 1,
                             'futures/batch-stop-order': 1,
+                            'futures/cancel-position-stop-loss': 20,
+                            'futures/cancel-position-take-profit': 20,
                             'futures/modify-order': 20,
                             'futures/modify-stop-order': 20,
                             'futures/batch-modify-order': 20,

package/js/src/krakenfutures.js

@@ -2693,7 +2693,7 @@ export default class krakenfutures extends Exchange {
         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/js/src/pro/aster.js

@@ -1481,23 +1481,26 @@ export default class aster extends asterRest {
         //     }
         //
         const messageHash = 'positions';
+        if (this.positions === undefined) {
+            this.positions = new 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 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);
@@ -1789,18 +1792,18 @@ export default class aster extends asterRest {
         //     }
         //
         const messageHash = 'orders';
+        const market = this.getMarketFromOrder(client, message);
+        if (this.orders === undefined) {
+            const limit = this.safeInteger(this.options, 'ordersLimit', 1000);
+            this.orders = new 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 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/js/src/pro/binance.js

@@ -352,13 +352,11 @@ export default class binance extends binanceRest {
         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 ArrayCache(limit);
+        if (this.liquidations === undefined) {
+            this.liquidations = new ArrayCacheBySymbolBySide();
         }
-        liquidations.append(liquidation);
-        this.liquidations[symbol] = liquidations;
+        const cache = this.liquidations;
+        cache.append(liquidation);
         client.resolve([liquidation], 'liquidations');
         client.resolve([liquidation], 'liquidations::' + symbol);
     }
@@ -563,13 +561,12 @@ export default class binance extends binanceRest {
         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 ArrayCache(limit);
+        let cache = this.myLiquidations;
+        if (cache === undefined) {
+            cache = new ArrayCacheBySymbolBySide();
         }
-        myLiquidations.append(liquidation);
-        this.myLiquidations[symbol] = myLiquidations;
+        cache.append(liquidation);
+        this.myLiquidations = cache;
         client.resolve([liquidation], 'myLiquidations');
         client.resolve([liquidation], 'myLiquidations::' + symbol);
     }

package/js/src/pro/bitmex.js

@@ -442,17 +442,14 @@ export default class bitmex extends bitmexRest {
         //
         const rawLiquidations = this.safeValue(message, 'data', []);
         const newLiquidations = [];
+        if (this.liquidations === undefined) {
+            this.liquidations = new 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 ArrayCache(limit);
-            }
-            liquidations.append(liquidation);
-            this.liquidations[symbol] = liquidations;
+            cache.append(liquidation);
             newLiquidations.push(liquidation);
         }
         client.resolve(newLiquidations, 'liquidations');

package/js/src/pro/bybit.js

@@ -1696,13 +1696,11 @@ export default class bybit extends bybitRest {
                 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 ArrayCache(limit);
+                if (this.liquidations === undefined) {
+                    this.liquidations = new ArrayCacheBySymbolBySide();
                 }
-                liquidations.append(liquidation);
-                this.liquidations[symbol] = liquidations;
+                const cache = this.liquidations;
+                cache.append(liquidation);
                 client.resolve([liquidation], 'liquidations');
                 client.resolve([liquidation], 'liquidations::' + symbol);
             }
@@ -1713,13 +1711,11 @@ export default class bybit extends bybitRest {
             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 ArrayCache(limit);
+            if (this.liquidations === undefined) {
+                this.liquidations = new ArrayCacheBySymbolBySide();
             }
-            liquidations.append(liquidation);
-            this.liquidations[symbol] = liquidations;
+            const cache = this.liquidations;
+            cache.append(liquidation);
             client.resolve([liquidation], 'liquidations');
             client.resolve([liquidation], 'liquidations::' + symbol);
         }

package/js/src/pro/bydfi.js

@@ -618,30 +618,19 @@ export default class bydfi extends bydfiRest {
         const marketId = this.safeString(rawOrder, 's');
         const market = this.safeMarket(marketId);
         const symbol = market['symbol'];
-        let match = false;
         const messageHash = 'orders';
         const symbolMessageHash = messageHash + '::' + symbol;
-        const messageHashes = this.findMessageHashes(client, messageHash);
-        for (let i = 0; i < messageHashes.length; i++) {
-            const hash = messageHashes[i];
-            if (hash === symbolMessageHash || hash === messageHash) {
-                match = true;
-                break;
-            }
-        }
-        if (match) {
-            if (this.orders === undefined) {
-                const limit = this.safeInteger(this.options, 'ordersLimit', 1000);
-                this.orders = new ArrayCacheBySymbolById(limit);
-            }
-            const orders = this.orders;
-            const order = this.parseWsOrder(rawOrder, market);
-            const lastUpdateTimestamp = this.safeInteger(message, 'T');
-            order['lastUpdateTimestamp'] = lastUpdateTimestamp;
-            orders.append(order);
-            client.resolve(orders, messageHash);
-            client.resolve(orders, symbolMessageHash);
+        if (this.orders === undefined) {
+            const limit = this.safeInteger(this.options, 'ordersLimit', 1000);
+            this.orders = new ArrayCacheBySymbolById(limit);
         }
+        const orders = this.orders;
+        const order = this.parseWsOrder(rawOrder, market);
+        const lastUpdateTimestamp = this.safeInteger(message, 'T');
+        order['lastUpdateTimestamp'] = lastUpdateTimestamp;
+        orders.append(order);
+        client.resolve(orders, messageHash);
+        client.resolve(orders, symbolMessageHash);
     }
     parseWsOrder(order, market = undefined) {
         //
@@ -787,29 +776,17 @@ export default class bydfi extends bydfiRest {
         const symbol = market['symbol'];
         const messageHash = 'positions';
         const symbolMessageHash = messageHash + '::' + symbol;
-        const messageHashes = this.findMessageHashes(client, messageHash);
-        let match = false;
-        for (let i = 0; i < messageHashes.length; i++) {
-            const hash = messageHashes[i];
-            if (hash === symbolMessageHash || hash === messageHash) {
-                match = true;
-                break;
-            }
-        }
-        if (match) {
-            if (this.positions === undefined) {
-                this.positions = new ArrayCacheBySymbolBySide();
-            }
-            const cache = this.positions;
-            const parsedPosition = this.parseWsPosition(rawPosition, market);
-            const timestamp = this.safeInteger(message, 'T');
-            parsedPosition['timestamp'] = timestamp;
-            parsedPosition['datetime'] = this.iso8601(timestamp);
-            cache.append(parsedPosition);
-            const symbolSpecificMessageHash = messageHash + ':' + parsedPosition['symbol'];
-            client.resolve([parsedPosition], messageHash);
-            client.resolve([parsedPosition], symbolSpecificMessageHash);
+        if (this.positions === undefined) {
+            this.positions = new ArrayCacheBySymbolBySide();
         }
+        const cache = this.positions;
+        const parsedPosition = this.parseWsPosition(rawPosition, market);
+        const timestamp = this.safeInteger(message, 'T');
+        parsedPosition['timestamp'] = timestamp;
+        parsedPosition['datetime'] = this.iso8601(timestamp);
+        cache.append(parsedPosition);
+        client.resolve([parsedPosition], messageHash);
+        client.resolve([parsedPosition], symbolMessageHash);
     }
     parseWsPosition(position, market = undefined) {
         //

package/js/src/pro/gate.js

@@ -1524,18 +1524,17 @@ export default class gate extends gateRest {
         //
         const rawLiquidations = this.safeList(message, 'result', []);
         const newLiquidations = [];
+        if (this.liquidations === undefined) {
+            this.liquidations = new ArrayCacheBySymbolBySide();
+        }
+        const cache = this.liquidations;
         for (let i = 0; i < rawLiquidations.length; i++) {
             const rawLiquidation = rawLiquidations[i];
             const liquidation = this.parseWsLiquidation(rawLiquidation);
+            cache.append(liquidation);
             const symbol = this.safeString(liquidation, 'symbol');
-            let liquidations = this.safeValue(this.liquidations, symbol);
-            if (liquidations === undefined) {
-                const limit = this.safeInteger(this.options, 'liquidationsLimit', 1000);
-                liquidations = new ArrayCache(limit);
-            }
-            liquidations.append(liquidation);
-            this.liquidations[symbol] = liquidations;
-            client.resolve(liquidations, 'myLiquidations::' + symbol);
+            const symbolLiquidations = this.safeValue(cache, symbol, []);
+            client.resolve(symbolLiquidations, 'myLiquidations::' + symbol);
         }
         client.resolve(newLiquidations, 'myLiquidations');
     }

package/js/src/pro/okx.js

@@ -758,13 +758,11 @@ export default class okx extends okxRest {
             const rawLiquidation = rawLiquidations[i];
             const liquidation = this.parseWsLiquidation(rawLiquidation);
             const symbol = this.safeString(liquidation, 'symbol');
-            let liquidations = this.safeValue(this.liquidations, symbol);
-            if (liquidations === undefined) {
-                const limit = this.safeInteger(this.options, 'liquidationsLimit', 1000);
-                liquidations = new ArrayCache(limit);
+            if (this.liquidations === undefined) {
+                this.liquidations = new ArrayCacheBySymbolBySide();
             }
-            liquidations.append(liquidation);
-            this.liquidations[symbol] = liquidations;
+            const cache = this.liquidations;
+            cache.append(liquidation);
             client.resolve([liquidation], 'liquidations');
             client.resolve([liquidation], 'liquidations::' + symbol);
         }
@@ -857,13 +855,11 @@ export default class okx extends okxRest {
             }
             const liquidation = this.parseWsMyLiquidation(rawLiquidation);
             const symbol = this.safeString(liquidation, 'symbol');
-            let liquidations = this.safeValue(this.liquidations, symbol);
-            if (liquidations === undefined) {
-                const limit = this.safeInteger(this.options, 'myLiquidationsLimit', 1000);
-                liquidations = new ArrayCache(limit);
+            if (this.liquidations === undefined) {
+                this.liquidations = new ArrayCacheBySymbolBySide();
             }
-            liquidations.append(liquidation);
-            this.liquidations[symbol] = liquidations;
+            const cache = this.liquidations;
+            cache.append(liquidation);
             client.resolve([liquidation], 'myLiquidations');
             client.resolve([liquidation], 'myLiquidations::' + symbol);
         }

package/js/src/woo.js

@@ -2151,7 +2151,7 @@ export default class woo extends Exchange {
             request['limit'] = Math.min(limit, 1000);
         }
         if (since !== undefined) {
-            request['after'] = since;
+            request['after'] = since - 1; // #27793
         }
         const until = this.safeInteger(params, 'until');
         params = this.omit(params, 'until');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccxt",
-  "version": "4.5.35",
+  "version": "4.5.36",
   "description": "A cryptocurrency trading API with more than 100 exchanges in JavaScript / TypeScript / Python / C# / PHP / Go",
   "unpkg": "dist/ccxt.browser.min.js",
   "type": "module",