ccxt 4.3.88 → 4.3.89

package/js/src/okcoin.js

@@ -580,6 +580,9 @@ export default class okcoin extends Exchange {
                 'defaultNetwork': 'ERC20',
                 'networks': {
                     'ERC20': 'Ethereum',
+                    'BTC': 'Bitcoin',
+                    'OMNI': 'Omni',
+                    'TRC20': 'TRON',
                 },
             },
             'commonCurrencies': {
@@ -712,14 +715,6 @@ export default class okcoin extends Exchange {
             'info': market,
         });
     }
-    safeNetwork(networkId) {
-        const networksById = {
-            'Bitcoin': 'BTC',
-            'Omni': 'OMNI',
-            'TRON': 'TRC20',
-        };
-        return this.safeString(networksById, networkId, networkId);
-    }
     async fetchCurrencies(params = {}) {
         /**
          * @method
@@ -763,7 +758,7 @@ export default class okcoin extends Exchange {
                     if ((networkId !== undefined) && (networkId.indexOf('-') >= 0)) {
                         const parts = networkId.split('-');
                         const chainPart = this.safeString(parts, 1, networkId);
-                        const networkCode = this.safeNetwork(chainPart);
+                        const networkCode = this.networkIdToCode(chainPart);
                         const precision = this.parsePrecision(this.safeString(chain, 'wdTickSz'));
                         if (maxPrecision === undefined) {
                             maxPrecision = precision;

package/js/src/onetrading.js

@@ -1644,6 +1644,7 @@ export default class onetrading extends Exchange {
          * @method
          * @name onetrading#fetchOrder
          * @description fetches information on an order made by the user
+         * @param {string} id the order id
          * @param {string} symbol not used by onetrading fetchOrder
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}

package/js/src/phemex.js

@@ -2986,6 +2986,7 @@ export default class phemex extends Exchange {
          * @name phemex#fetchOrder
          * @see https://phemex-docs.github.io/#query-orders-by-ids
          * @description fetches information on an order made by the user
+         * @param {string} id the 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
          * @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}

package/js/src/poloniexfutures.js

@@ -1418,6 +1418,7 @@ export default class poloniexfutures extends Exchange {
          * @description fetches information on an order made by the user
          * @see https://api-docs.poloniex.com/futures/api/orders#get-details-of-a-single-order
          * @see https://api-docs.poloniex.com/futures/api/orders#get-single-order-by-clientoid
+         * @param {string} id the 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
          * @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}

package/js/src/pro/bitvavo.js

@@ -642,6 +642,7 @@ export default class bitvavo extends bitvavoRest {
          * @name bitvavo#fetchOrderWs
          * @see https://docs.bitvavo.com/#tag/General/paths/~1assets/get
          * @description fetches information on an order made by the user
+         * @param {string} id the order id
          * @param {string} symbol unified symbol of the market the order was made in
          * @param {object} [params] extra parameters specific to the bitvavo api endpoint
          * @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}

package/js/src/pro/bybit.d.ts

@@ -1,5 +1,5 @@
 import bybitRest from '../bybit.js';
-import type { Int, OHLCV, Str, Strings, Ticker, OrderBook, Order, Trade, Tickers, Position, Balances, OrderType, OrderSide, Num, Liquidation } from '../base/types.js';
+import type { Int, OHLCV, Str, Strings, Ticker, OrderBook, Order, Trade, Tickers, Position, Balances, OrderType, OrderSide, Num, Dict, Liquidation } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class bybit extends bybitRest {
     describe(): any;
@@ -11,6 +11,8 @@ export default class bybit extends bybitRest {
     cancelOrderWs(id: string, symbol?: Str, params?: {}): Promise<Order>;
     watchTicker(symbol: string, params?: {}): Promise<Ticker>;
     watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
+    unWatchTickers(symbols?: Strings, params?: {}): Promise<any>;
+    unWatchTicker(symbols: string, params?: {}): Promise<any>;
     handleTicker(client: Client, message: any): void;
     watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     watchOHLCVForSymbols(symbolsAndTimeframes: string[][], since?: Int, limit?: Int, params?: {}): Promise<import("../base/types.js").Dictionary<import("../base/types.js").Dictionary<OHLCV[]>>>;
@@ -18,15 +20,20 @@ export default class bybit extends bybitRest {
     parseWsOHLCV(ohlcv: any, market?: any): OHLCV;
     watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     watchOrderBookForSymbols(symbols: string[], limit?: Int, params?: {}): Promise<OrderBook>;
+    unWatchOrderBookForSymbols(symbols: Strings, params?: {}): Promise<any>;
+    unWatchOrderBook(symbol: string, params?: {}): Promise<any>;
     handleOrderBook(client: Client, message: any): void;
     handleDelta(bookside: any, delta: any): void;
     handleDeltas(bookside: any, deltas: any): void;
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     watchTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    unWatchTradesForSymbols(symbols: Strings, params?: {}): Promise<any>;
+    unWatchTrades(symbol: string, params?: {}): Promise<any>;
     handleTrades(client: Client, message: any): void;
     parseWsTrade(trade: any, market?: any): Trade;
     getPrivateType(url: any): "spot" | "unified" | "usdc";
     watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    unWatchMyTrades(symbol?: Str, params?: {}): Promise<any>;
     handleMyTrades(client: Client, message: any): void;
     watchPositions(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<Position[]>;
     setPositionsCache(client: Client, symbols?: Strings): void;
@@ -36,6 +43,7 @@ export default class bybit extends bybitRest {
     handleLiquidation(client: Client, message: any): void;
     parseWsLiquidation(liquidation: any, market?: any): Liquidation;
     watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    unWatchOrders(symbol?: Str, params?: {}): Promise<any>;
     handleOrderWs(client: Client, message: any): void;
     handleOrder(client: Client, message: any): void;
     parseWsSpotOrder(order: any, market?: any): Order;
@@ -43,6 +51,7 @@ export default class bybit extends bybitRest {
     handleBalance(client: Client, message: any): void;
     parseWsBalance(balance: any, accountType?: any): void;
     watchTopics(url: any, messageHashes: any, topics: any, params?: {}): Promise<any>;
+    unWatchTopics(url: string, topic: string, symbols: string[], messageHashes: string[], subMessageHashes: string[], topics: any, params?: {}): Promise<any>;
     authenticate(url: any, params?: {}): Promise<any>;
     handleErrorMessage(client: Client, message: any): boolean;
     handleMessage(client: Client, message: any): void;
@@ -53,4 +62,6 @@ export default class bybit extends bybitRest {
     handlePong(client: Client, message: any): any;
     handleAuthenticate(client: Client, message: any): any;
     handleSubscriptionStatus(client: Client, message: any): any;
+    handleUnSubscribe(client: Client, message: any): any;
+    cleanCache(subscription: Dict): void;
 }

package/js/src/pro/bybit.js

@@ -6,7 +6,7 @@
 
 //  ---------------------------------------------------------------------------
 import bybitRest from '../bybit.js';
-import { ArgumentsRequired, AuthenticationError, ExchangeError, BadRequest } from '../base/errors.js';
+import { ArgumentsRequired, AuthenticationError, ExchangeError, BadRequest, UnsubscribeError } from '../base/errors.js';
 import { ArrayCache, ArrayCacheBySymbolById, ArrayCacheBySymbolBySide, ArrayCacheByTimestamp } from '../base/ws/Cache.js';
 import { sha256 } from '../static_dependencies/noble-hashes/sha256.js';
 //  ---------------------------------------------------------------------------
@@ -393,6 +393,49 @@ export default class bybit extends bybitRest {
         }
         return this.filterByArray(this.tickers, 'symbol', symbols);
     }
+    async unWatchTickers(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name bybit#unWatchTickers
+         * @description unWatches a price ticker
+         * @see https://bybit-exchange.github.io/docs/v5/websocket/public/ticker
+         * @see https://bybit-exchange.github.io/docs/v5/websocket/public/etp-ticker
+         * @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, false);
+        const options = this.safeValue(this.options, 'watchTickers', {});
+        const topic = this.safeString(options, 'name', 'tickers');
+        const messageHashes = [];
+        const subMessageHashes = [];
+        const marketIds = this.marketIds(symbols);
+        const topics = [];
+        for (let i = 0; i < marketIds.length; i++) {
+            const marketId = marketIds[i];
+            const symbol = symbols[i];
+            topics.push(topic + '.' + marketId);
+            subMessageHashes.push('ticker:' + symbol);
+            messageHashes.push('unsubscribe:ticker:' + symbol);
+        }
+        const url = await this.getUrlByMarketType(symbols[0], false, 'watchTickers', params);
+        return await this.unWatchTopics(url, 'ticker', symbols, messageHashes, subMessageHashes, topics, params);
+    }
+    async unWatchTicker(symbols, params = {}) {
+        /**
+         * @method
+         * @name bybit#unWatchTicker
+         * @description unWatches a price ticker
+         * @see https://bybit-exchange.github.io/docs/v5/websocket/public/ticker
+         * @see https://bybit-exchange.github.io/docs/v5/websocket/public/etp-ticker
+         * @param {string} symbol 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();
+        return await this.unWatchTickers([symbols], params);
+    }
     handleTicker(client, message) {
         //
         // linear
@@ -726,6 +769,56 @@ export default class bybit extends bybitRest {
         const orderbook = await this.watchTopics(url, messageHashes, topics, params);
         return orderbook.limit();
     }
+    async unWatchOrderBookForSymbols(symbols, params = {}) {
+        /**
+         * @method
+         * @name bybit#unWatchOrderBookForSymbols
+         * @description unsubscribe from the orderbook channel
+         * @see https://bybit-exchange.github.io/docs/v5/websocket/public/orderbook
+         * @param {string[]} symbols unified symbol of the market to unwatch the trades for
+         * @param {int} [params.limit] orderbook limit, default is undefined
+         * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
+         */
+        await this.loadMarkets();
+        symbols = this.marketSymbols(symbols, undefined, false);
+        let channel = 'orderbook.';
+        let limit = this.safeInteger(params, 'limit');
+        if (limit !== undefined) {
+            params = this.omit(params, 'limit');
+        }
+        else {
+            const firstMarket = this.market(symbols[0]);
+            limit = firstMarket['spot'] ? 50 : 500;
+        }
+        channel += limit.toString();
+        const subMessageHashes = [];
+        const messageHashes = [];
+        const topics = [];
+        for (let i = 0; i < symbols.length; i++) {
+            const symbol = symbols[i];
+            const market = this.market(symbol);
+            const marketId = market['id'];
+            const topic = channel + '.' + marketId;
+            messageHashes.push('unsubscribe:orderbook:' + symbol);
+            subMessageHashes.push('orderbook:' + symbol);
+            topics.push(topic);
+        }
+        const url = await this.getUrlByMarketType(symbols[0], false, 'watchOrderBook', params);
+        return await this.unWatchTopics(url, 'orderbook', symbols, messageHashes, subMessageHashes, topics, params);
+    }
+    async unWatchOrderBook(symbol, params = {}) {
+        /**
+         * @method
+         * @name bybit#unWatchOrderBook
+         * @description unsubscribe from the orderbook channel
+         * @see https://bybit-exchange.github.io/docs/v5/websocket/public/orderbook
+         * @param {string[]} symbols unified symbol of the market to unwatch the trades for
+         * @param {int} [params.limit] orderbook limit, default is undefined
+         * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
+         */
+        await this.loadMarkets();
+        return await this.unWatchOrderBookForSymbols([symbol], params);
+    }
     handleOrderBook(client, message) {
         //
         //     {
@@ -850,6 +943,44 @@ export default class bybit extends bybitRest {
         }
         return this.filterBySinceLimit(trades, since, limit, 'timestamp', true);
     }
+    async unWatchTradesForSymbols(symbols, params = {}) {
+        /**
+         * @method
+         * @name bybit#unWatchTradesForSymbols
+         * @description unsubscribe from the trades channel
+         * @see https://bybit-exchange.github.io/docs/v5/websocket/public/trade
+         * @param {string[]} symbols unified symbol of the market to unwatch the trades for
+         * @returns {any} status of the unwatch request
+         */
+        await this.loadMarkets();
+        symbols = this.marketSymbols(symbols, undefined, false, true);
+        const url = await this.getUrlByMarketType(symbols[0], false, 'unWatchTradesForSymbols', params);
+        const messageHashes = [];
+        const topics = [];
+        const subMessageHashes = [];
+        for (let i = 0; i < symbols.length; i++) {
+            const symbol = symbols[i];
+            const market = this.market(symbol);
+            const topic = 'publicTrade.' + market['id'];
+            topics.push(topic);
+            const messageHash = 'unsubscribe:trade:' + symbol;
+            messageHashes.push(messageHash);
+            subMessageHashes.push('trade:' + symbol);
+        }
+        return await this.unWatchTopics(url, 'trade', symbols, messageHashes, subMessageHashes, topics, params);
+    }
+    async unWatchTrades(symbol, params = {}) {
+        /**
+         * @method
+         * @name bybit#unWatchTrades
+         * @description unsubscribe from the trades channel
+         * @see https://bybit-exchange.github.io/docs/v5/websocket/public/trade
+         * @param {string} symbol unified symbol of the market to unwatch the trades for
+         * @returns {any} status of the unwatch request
+         */
+        await this.loadMarkets();
+        return await this.unWatchTradesForSymbols([symbol], params);
+    }
     handleTrades(client, message) {
         //
         //     {
@@ -1008,6 +1139,35 @@ export default class bybit extends bybitRest {
         }
         return this.filterBySymbolSinceLimit(trades, symbol, since, limit, true);
     }
+    async unWatchMyTrades(symbol = undefined, params = {}) {
+        /**
+         * @method
+         * @name bybit#unWatchMyTrades
+         * @description unWatches information on multiple trades made by the user
+         * @see https://bybit-exchange.github.io/docs/v5/websocket/private/execution
+         * @param {string} symbol unified market symbol of the market orders were made in
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {boolean} [params.unifiedMargin] use unified margin account
+         * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        const method = 'watchMyTrades';
+        const messageHash = 'unsubscribe:myTrades';
+        let subHash = 'myTrades';
+        await this.loadMarkets();
+        if (symbol !== undefined) {
+            symbol = this.symbol(symbol);
+            subHash += ':' + symbol;
+        }
+        const url = await this.getUrlByMarketType(symbol, true, method, params);
+        await this.authenticate(url);
+        const topicByMarket = {
+            'spot': 'ticketInfo',
+            'unified': 'execution',
+            'usdc': 'user.openapi.perp.trade',
+        };
+        const topic = this.safeValue(topicByMarket, this.getPrivateType(url));
+        return await this.unWatchTopics(url, 'myTrades', [], [messageHash], [subHash], [topic], params);
+    }
     handleMyTrades(client, message) {
         //
         // spot
@@ -1372,6 +1532,35 @@ export default class bybit extends bybitRest {
         }
         return this.filterBySymbolSinceLimit(orders, symbol, since, limit, true);
     }
+    async unWatchOrders(symbol = undefined, params = {}) {
+        /**
+         * @method
+         * @name bybit#unWatchOrders
+         * @description unWatches information on multiple orders made by the user
+         * @see https://bybit-exchange.github.io/docs/v5/websocket/private/order
+         * @param {string} symbol unified market symbol of the market orders were made in
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {boolean} [params.unifiedMargin] use unified margin account
+         * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        await this.loadMarkets();
+        const method = 'watchOrders';
+        const messageHash = 'unsubscribe:orders';
+        let subHash = 'orders';
+        if (symbol !== undefined) {
+            symbol = this.symbol(symbol);
+            subHash += ':' + symbol;
+        }
+        const url = await this.getUrlByMarketType(symbol, true, method, params);
+        await this.authenticate(url);
+        const topicsByMarket = {
+            'spot': ['order', 'stopOrder'],
+            'unified': ['order'],
+            'usdc': ['user.openapi.perp.order'],
+        };
+        const topics = this.safeValue(topicsByMarket, this.getPrivateType(url));
+        return await this.unWatchTopics(url, 'orders', [], [messageHash], [subHash], topics, params);
+    }
     handleOrderWs(client, message) {
         //
         //    {
@@ -1954,7 +2143,24 @@ export default class bybit extends bybitRest {
             'args': topics,
         };
         const message = this.extend(request, params);
-        return await this.watchMultiple(url, messageHashes, message, topics);
+        return await this.watchMultiple(url, messageHashes, message, messageHashes);
+    }
+    async unWatchTopics(url, topic, symbols, messageHashes, subMessageHashes, topics, params = {}) {
+        const reqId = this.requestId();
+        const request = {
+            'op': 'unsubscribe',
+            'req_id': reqId,
+            'args': topics,
+        };
+        const subscription = {
+            'id': reqId,
+            'topic': topic,
+            'messageHashes': messageHashes,
+            'subMessageHashes': subMessageHashes,
+            'symbols': symbols,
+        };
+        const message = this.extend(request, params);
+        return await this.watchMultiple(url, messageHashes, message, messageHashes, subscription);
     }
     async authenticate(url, params = {}) {
         this.checkRequiredCredentials();
@@ -2105,6 +2311,7 @@ export default class bybit extends bybitRest {
             'order.amend': this.handleOrderWs,
             'order.cancel': this.handleOrderWs,
             'auth': this.handleAuthenticate,
+            'unsubscribe': this.handleUnSubscribe,
         };
         const exacMethod = this.safeValue(methods, topic);
         if (exacMethod !== undefined) {
@@ -2195,4 +2402,86 @@ export default class bybit extends bybitRest {
         //
         return message;
     }
+    handleUnSubscribe(client, message) {
+        //
+        // {"success":true,"ret_msg":"","conn_id":"7188110e-6908-41e9-b863-6365127e92ad","req_id":"3","op":"unsubscribe"}
+        //
+        // client.subscription will be something like:
+        // {
+        //     "publicTrade.LTCUSDT":true,
+        //     "publicTrade.ADAUSDT":true,
+        //     "unsubscribe:trade:LTC/USDT:USDT": {
+        //        "id":4,
+        //         "subHash": "trade:LTC/USDT"
+        //     },
+        // }
+        const reqId = this.safeString(message, 'req_id');
+        const keys = Object.keys(client.subscriptions);
+        for (let i = 0; i < keys.length; i++) {
+            const messageHash = keys[i];
+            if (!(messageHash in client.subscriptions)) {
+                continue;
+                // the previous iteration can have deleted the messageHash from the subscriptions
+            }
+            if (messageHash.startsWith('unsubscribe')) {
+                const subscription = client.subscriptions[messageHash];
+                const subId = this.safeString(subscription, 'id');
+                if (reqId !== subId) {
+                    continue;
+                }
+                const messageHashes = this.safeList(subscription, 'messageHashes', []);
+                const subMessageHashes = this.safeList(subscription, 'subMessageHashes', []);
+                for (let j = 0; j < messageHashes.length; j++) {
+                    const unsubHash = messageHashes[j];
+                    const subHash = subMessageHashes[j];
+                    if (unsubHash in client.subscriptions) {
+                        delete client.subscriptions[unsubHash];
+                    }
+                    if (subHash in client.subscriptions) {
+                        delete client.subscriptions[subHash];
+                    }
+                    const error = new UnsubscribeError(this.id + ' ' + messageHash);
+                    client.reject(error, subHash);
+                    client.resolve(true, unsubHash);
+                    this.cleanCache(subscription);
+                }
+            }
+        }
+        return message;
+    }
+    cleanCache(subscription) {
+        const topic = this.safeString(subscription, 'topic');
+        const symbols = this.safeList(subscription, 'symbols', []);
+        const symbolsLength = symbols.length;
+        if (symbolsLength > 0) {
+            for (let i = 0; i < symbols.length; i++) {
+                const symbol = symbols[i];
+                if (topic === 'trade') {
+                    delete this.trades[symbol];
+                }
+                else if (topic === 'orderbook') {
+                    delete this.orderbooks[symbol];
+                }
+                else if (topic === 'ticker') {
+                    delete this.tickers[symbol];
+                }
+            }
+        }
+        else {
+            if (topic === 'myTrades') {
+                // don't reset this.myTrades directly here
+                // because in c# we need to use a different object
+                const keys = Object.keys(this.myTrades);
+                for (let i = 0; i < keys.length; i++) {
+                    delete this.myTrades[keys[i]];
+                }
+            }
+            else if (topic === 'orders') {
+                const orderSymbols = Object.keys(this.orders);
+                for (let i = 0; i < orderSymbols.length; i++) {
+                    delete this.orders[orderSymbols[i]];
+                }
+            }
+        }
+    }
 }

package/js/src/pro/cex.js

@@ -1195,6 +1195,7 @@ export default class cex extends cexRest {
          * @name cex#fetchOrderWs
          * @description fetches information on an order made by the user
          * @see https://docs.cex.io/#ws-api-get-order
+         * @param {string} id the order id
          * @param {string} symbol not used by cex fetchOrder
          * @param {object} [params] extra parameters specific to the cex api endpoint
          * @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}

package/js/src/probit.js

@@ -1076,6 +1076,7 @@ export default class probit extends Exchange {
          * @name probit#fetchOrder
          * @see https://docs-en.probit.com/reference/order-3
          * @description fetches information on an order made by the user
+         * @param {string} id the 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
          * @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}

package/js/src/vertex.js

@@ -1971,6 +1971,7 @@ export default class vertex extends Exchange {
          * @name vertex#fetchOrder
          * @description fetches information on an order made by the user
          * @see https://docs.vertexprotocol.com/developer-resources/api/gateway/queries/order
+         * @param {string} id the 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
          * @returns {object} An [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}

package/js/src/woo.js

@@ -1369,6 +1369,7 @@ export default class woo extends Exchange {
          * @see https://docs.woo.org/#get-algo-order
          * @see https://docs.woo.org/#get-order
          * @description fetches information on an order made by the user
+         * @param {string} id the 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 {boolean} [params.stop] whether the order is a stop/algo order

package/js/src/woofipro.js

@@ -1716,6 +1716,7 @@ export default class woofipro extends Exchange {
          * @see https://orderly.network/docs/build-on-evm/evm-api/restful-api/private/get-algo-order-by-order_id
          * @see https://orderly.network/docs/build-on-evm/evm-api/restful-api/private/get-algo-order-by-client_order_id
          * @description fetches information on an order made by the user
+         * @param {string} id the 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 {boolean} [params.trigger] whether the order is a stop/algo order

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccxt",
-  "version": "4.3.88",
+  "version": "4.3.89",
   "description": "A JavaScript / TypeScript / Python / C# / PHP cryptocurrency trading library with support for 100+ exchanges",
   "unpkg": "dist/ccxt.browser.min.js",
   "type": "module",