ccxt 4.4.1 → 4.4.3

package/js/src/pro/kucoinfutures.js

@@ -178,6 +178,27 @@ export default class kucoinfutures extends kucoinfuturesRest {
         };
         return await this.watchMultiple(url, messageHashes, this.extend(request, params), subscriptionHashes, subscriptionArgs);
     }
+    async unSubscribeMultiple(url, messageHashes, topic, subscriptionHashes, params = {}, subscription = undefined) {
+        const requestId = this.requestId().toString();
+        const request = {
+            'id': requestId,
+            'type': 'unsubscribe',
+            'topic': topic,
+            'response': true,
+        };
+        const message = this.extend(request, params);
+        if (subscription !== undefined) {
+            subscription[requestId] = requestId;
+        }
+        const client = this.client(url);
+        for (let i = 0; i < subscriptionHashes.length; i++) {
+            const subscriptionHash = subscriptionHashes[i];
+            if (!(subscriptionHash in client.subscriptions)) {
+                client.subscriptions[requestId] = subscriptionHash;
+            }
+        }
+        return await this.watchMultiple(url, messageHashes, message, subscriptionHashes, subscription);
+    }
     async watchTicker(symbol, params = {}) {
         /**
          * @method
@@ -521,7 +542,7 @@ export default class kucoinfutures extends kucoinfuturesRest {
     async watchTradesForSymbols(symbols, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
-         * @name kucoinfutures#watchTrades
+         * @name kucoinfutures#watchTradesForSymbols
          * @description get the list of most recent trades for a particular symbol
          * @param {string} symbol unified symbol of the market to fetch trades for
          * @param {int} [since] timestamp in ms of the earliest trade to fetch
@@ -555,6 +576,49 @@ export default class kucoinfutures extends kucoinfuturesRest {
         }
         return this.filterBySinceLimit(trades, since, limit, 'timestamp', true);
     }
+    async unWatchTrades(symbol, params = {}) {
+        /**
+         * @method
+         * @name kucoinfutures#unWatchTrades
+         * @description unWatches trades stream
+         * @see https://docs.kucoin.com/futures/#execution-data
+         * @param {string} symbol unified symbol of the market to fetch trades for
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades}
+         */
+        return await this.unWatchTradesForSymbols([symbol], params);
+    }
+    async unWatchTradesForSymbols(symbols, params = {}) {
+        /**
+         * @method
+         * @name kucoinfutures#unWatchTradesForSymbols
+         * @description get the list of most recent trades for a particular symbol
+         * @param {string} symbol unified symbol of the market to fetch trades for
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades}
+         */
+        await this.loadMarkets();
+        symbols = this.marketSymbols(symbols, undefined, false);
+        const url = await this.negotiate(false);
+        symbols = this.marketSymbols(symbols);
+        const marketIds = this.marketIds(symbols);
+        const topic = '/contractMarket/execution:' + marketIds.join(',');
+        const subscriptionHashes = [];
+        const messageHashes = [];
+        for (let i = 0; i < symbols.length; i++) {
+            const symbol = symbols[i];
+            messageHashes.push('unsubscribe:trades:' + symbol);
+            subscriptionHashes.push('trades:' + symbol);
+        }
+        const subscription = {
+            'messageHashes': messageHashes,
+            'subMessageHashes': subscriptionHashes,
+            'topic': 'trades',
+            'unsubscribe': true,
+            'symbols': symbols,
+        };
+        return await this.unSubscribeMultiple(url, messageHashes, topic, messageHashes, params, subscription);
+    }
     handleTrade(client, message) {
         //
         //    {
@@ -689,6 +753,7 @@ export default class kucoinfutures extends kucoinfuturesRest {
          * @method
          * @name kucoinfutures#watchOrderBookForSymbols
          * @description watches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
+         * @see https://docs.kucoin.com/futures/#level-2-market-data
          * @param {string[]} symbols unified array of symbols
          * @param {int} [limit] the maximum amount of order book entries to return
          * @param {object} [params] extra parameters specific to the exchange API endpoint
@@ -722,6 +787,48 @@ export default class kucoinfutures extends kucoinfuturesRest {
         const orderbook = await this.subscribeMultiple(url, messageHashes, topic, subscriptionHashes, subscriptionArgs, params);
         return orderbook.limit();
     }
+    async unWatchOrderBook(symbol, params = {}) {
+        /**
+         * @method
+         * @name kucoinfutures#unWatchOrderBook
+         * @description unWatches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
+         * @see https://docs.kucoin.com/futures/#level-2-market-data
+         * @param {string} symbol unified symbol of the market to fetch the order book for
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
+         */
+        return await this.unWatchOrderBookForSymbols([symbol], params);
+    }
+    async unWatchOrderBookForSymbols(symbols, params = {}) {
+        /**
+         * @method
+         * @name kucoinfutures#unWatchOrderBookForSymbols
+         * @description unWatches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
+         * @param {string[]} symbols unified array of symbols
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @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);
+        const marketIds = this.marketIds(symbols);
+        const url = await this.negotiate(false);
+        const topic = '/contractMarket/level2:' + marketIds.join(',');
+        const subscriptionHashes = [];
+        const messageHashes = [];
+        for (let i = 0; i < symbols.length; i++) {
+            const symbol = symbols[i];
+            messageHashes.push('unsubscribe:orderbook:' + symbol);
+            subscriptionHashes.push('orderbook:' + symbol);
+        }
+        const subscription = {
+            'messageHashes': messageHashes,
+            'symbols': symbols,
+            'unsubscribe': true,
+            'topic': 'orderbook',
+            'subMessageHashes': subscriptionHashes,
+        };
+        return await this.unSubscribeMultiple(url, messageHashes, topic, messageHashes, params, subscription);
+    }
     handleDelta(orderbook, delta) {
         orderbook['nonce'] = this.safeInteger(delta, 'sequence');
         const timestamp = this.safeInteger(delta, 'timestamp');
@@ -1139,6 +1246,36 @@ export default class kucoinfutures extends kucoinfuturesRest {
         }
         this.handleErrors(undefined, undefined, client.url, undefined, undefined, data, message, undefined, undefined);
     }
+    handleSubscriptionStatus(client, message) {
+        //
+        //     {
+        //         "id": "1578090438322",
+        //         "type": "ack"
+        //     }
+        //
+        const id = this.safeString(message, 'id');
+        if (!(id in client.subscriptions)) {
+            return;
+        }
+        const subscriptionHash = this.safeString(client.subscriptions, id);
+        const subscription = this.safeValue(client.subscriptions, subscriptionHash);
+        delete client.subscriptions[id];
+        const method = this.safeValue(subscription, 'method');
+        if (method !== undefined) {
+            method.call(this, client, message, subscription);
+        }
+        const isUnSub = this.safeBool(subscription, 'unsubscribe', false);
+        if (isUnSub) {
+            const messageHashes = this.safeList(subscription, 'messageHashes', []);
+            const subMessageHashes = this.safeList(subscription, 'subMessageHashes', []);
+            for (let i = 0; i < messageHashes.length; i++) {
+                const messageHash = messageHashes[i];
+                const subHash = subMessageHashes[i];
+                this.cleanUnsubscription(client, subHash, messageHash);
+            }
+            this.cleanCache(subscription);
+        }
+    }
     handleMessage(client, message) {
         const type = this.safeString(message, 'type');
         const methods = {
@@ -1147,6 +1284,7 @@ export default class kucoinfutures extends kucoinfuturesRest {
             'message': this.handleSubject,
             'pong': this.handlePong,
             'error': this.handleErrorMessage,
+            'ack': this.handleSubscriptionStatus,
         };
         const method = this.safeValue(methods, type);
         if (method !== undefined) {

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

@@ -1,10 +1,12 @@
 import mexcRest from '../mexc.js';
-import type { Int, OHLCV, Str, OrderBook, Order, Trade, Ticker, Balances } from '../base/types.js';
+import type { Int, OHLCV, Str, OrderBook, Order, Trade, Ticker, Balances, Strings, Tickers } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class mexc extends mexcRest {
     describe(): any;
     watchTicker(symbol: string, params?: {}): Promise<Ticker>;
     handleTicker(client: Client, message: any): void;
+    watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
+    handleTickers(client: Client, message: any): void;
     parseWsTicker(ticker: any, market?: any): Ticker;
     watchSpotPublic(channel: any, messageHash: any, params?: {}): Promise<any>;
     watchSpotPrivate(channel: any, messageHash: any, params?: {}): Promise<any>;

package/js/src/pro/mexc.js

@@ -30,7 +30,7 @@ export default class mexc extends mexcRest {
                 'watchOrderBook': true,
                 'watchOrders': true,
                 'watchTicker': true,
-                'watchTickers': false,
+                'watchTickers': true,
                 'watchTrades': true,
                 'watchTradesForSymbols': false,
             },
@@ -128,6 +128,84 @@ export default class mexc extends mexcRest {
         const messageHash = 'ticker:' + symbol;
         client.resolve(ticker, messageHash);
     }
+    async watchTickers(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name mexc#watchTickers
+         * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
+         * @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#individual-symbol-book-ticker-streams
+         * @see https://mexcdevelop.github.io/apidocs/contract_v1_en/#public-channels
+         * @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 messageHashes = [];
+        const marketIds = this.marketIds(symbols);
+        const firstMarket = this.market(symbols[0]);
+        const isSpot = firstMarket['spot'];
+        const url = (isSpot) ? this.urls['api']['ws']['spot'] : this.urls['api']['ws']['swap'];
+        const request = {};
+        if (isSpot) {
+            const topics = [];
+            for (let i = 0; i < marketIds.length; i++) {
+                const marketId = marketIds[i];
+                messageHashes.push('ticker:' + symbols[i]);
+                topics.push('spot@public.bookTicker.v3.api@' + marketId);
+            }
+            request['method'] = 'SUBSCRIPTION';
+            request['params'] = topics;
+        }
+        else {
+            request['method'] = 'sub.tickers';
+            request['params'] = {};
+            messageHashes.push('ticker');
+        }
+        const ticker = await this.watchMultiple(url, messageHashes, this.extend(request, params), messageHashes);
+        if (isSpot && this.newUpdates) {
+            const result = {};
+            result[ticker['symbol']] = ticker;
+            return result;
+        }
+        return this.filterByArray(this.tickers, 'symbol', symbols);
+    }
+    handleTickers(client, message) {
+        //
+        //     {
+        //       "channel": "push.tickers",
+        //       "data": [
+        //         {
+        //           "symbol": "ETH_USDT",
+        //           "lastPrice": 2324.5,
+        //           "riseFallRate": 0.0356,
+        //           "fairPrice": 2324.32,
+        //           "indexPrice": 2325.44,
+        //           "volume24": 25868309,
+        //           "amount24": 591752573.9792,
+        //           "maxBidPrice": 2557.98,
+        //           "minAskPrice": 2092.89,
+        //           "lower24Price": 2239.39,
+        //           "high24Price": 2332.59,
+        //           "timestamp": 1725872514111
+        //         }
+        //       ],
+        //       "ts": 1725872514111
+        //     }
+        //
+        const data = this.safeList(message, 'data');
+        const topic = 'ticker';
+        const result = [];
+        for (let i = 0; i < data.length; i++) {
+            const ticker = this.parseTicker(data[i]);
+            const symbol = ticker['symbol'];
+            this.tickers[symbol] = ticker;
+            result.push(ticker);
+            const messageHash = topic + ':' + symbol;
+            client.resolve(ticker, messageHash);
+        }
+        client.resolve(result, topic);
+    }
     parseWsTicker(ticker, market = undefined) {
         //
         // spot
@@ -1135,8 +1213,8 @@ export default class mexc extends mexcRest {
         //        "code": 0,
         //        "msg": "spot@public.increase.depth.v3.api@BTCUSDT"
         //    }
-        //
-        const msg = this.safeString(message, 'msg');
+        // Set the default to an empty string if the message is empty during the test.
+        const msg = this.safeString(message, 'msg', '');
         if (msg === 'PONG') {
             this.handlePong(client, message);
         }
@@ -1180,6 +1258,7 @@ export default class mexc extends mexcRest {
             'push.kline': this.handleOHLCV,
             'public.bookTicker.v3.api': this.handleTicker,
             'push.ticker': this.handleTicker,
+            'push.tickers': this.handleTickers,
             'public.increase.depth.v3.api': this.handleOrderBook,
             'push.depth': this.handleOrderBook,
             'private.orders.v3.api': this.handleOrder,

package/js/src/pro/okx.js

@@ -6,7 +6,7 @@
 
 //  ---------------------------------------------------------------------------
 import okxRest from '../okx.js';
-import { ArgumentsRequired, BadRequest, ExchangeError, ChecksumError, AuthenticationError, InvalidNonce, UnsubscribeError } from '../base/errors.js';
+import { ArgumentsRequired, BadRequest, ExchangeError, ChecksumError, AuthenticationError, InvalidNonce } from '../base/errors.js';
 import { ArrayCache, ArrayCacheByTimestamp, ArrayCacheBySymbolById, ArrayCacheBySymbolBySide } from '../base/ws/Cache.js';
 import { sha256 } from '../static_dependencies/noble-hashes/sha256.js';
 //  ---------------------------------------------------------------------------
@@ -1445,8 +1445,11 @@ export default class okx extends okxRest {
                     },
                 ],
             };
-            const message = this.extend(request, params);
-            this.watch(url, messageHash, message, messageHash);
+            // Only add params['access'] to prevent sending custom parameters, such as extraParams.
+            if ('access' in params) {
+                request['access'] = params['access'];
+            }
+            this.watch(url, messageHash, request, messageHash);
         }
         return await future;
     }
@@ -1616,7 +1619,7 @@ export default class okx extends okxRest {
                 'channel': 'positions',
                 'instType': 'ANY',
             };
-            const args = [arg];
+            const args = [this.extend(arg, params)];
             const nonSymbolRequest = {
                 'op': 'subscribe',
                 'args': args,
@@ -2336,64 +2339,36 @@ export default class okx extends okxRest {
     handleUnSubscriptionTrades(client, symbol) {
         const subMessageHash = 'trades:' + symbol;
         const messageHash = 'unsubscribe:trades:' + symbol;
-        if (subMessageHash in client.subscriptions) {
-            delete client.subscriptions[subMessageHash];
-        }
-        if (messageHash in client.subscriptions) {
-            delete client.subscriptions[messageHash];
+        this.cleanUnsubscription(client, subMessageHash, messageHash);
+        if (symbol in this.trades) {
+            delete this.trades[symbol];
         }
-        delete this.trades[symbol];
-        const error = new UnsubscribeError(this.id + ' ' + subMessageHash);
-        client.reject(error, subMessageHash);
-        client.resolve(true, messageHash);
     }
     handleUnsubscriptionOrderBook(client, symbol, channel) {
         const subMessageHash = channel + ':' + symbol;
         const messageHash = 'unsubscribe:orderbook:' + symbol;
-        if (subMessageHash in client.subscriptions) {
-            delete client.subscriptions[subMessageHash];
+        this.cleanUnsubscription(client, subMessageHash, messageHash);
+        if (symbol in this.orderbooks) {
+            delete this.orderbooks[symbol];
         }
-        if (messageHash in client.subscriptions) {
-            delete client.subscriptions[messageHash];
-        }
-        delete this.orderbooks[symbol];
-        const error = new UnsubscribeError(this.id + ' ' + subMessageHash);
-        client.reject(error, subMessageHash);
-        client.resolve(true, messageHash);
     }
     handleUnsubscriptionOHLCV(client, symbol, channel) {
         const tf = channel.replace('candle', '');
         const timeframe = this.findTimeframe(tf);
         const subMessageHash = 'multi:' + channel + ':' + symbol;
         const messageHash = 'unsubscribe:' + subMessageHash;
-        if (subMessageHash in client.subscriptions) {
-            delete client.subscriptions[subMessageHash];
-        }
-        if (messageHash in client.subscriptions) {
-            delete client.subscriptions[messageHash];
-        }
+        this.cleanUnsubscription(client, subMessageHash, messageHash);
         if (timeframe in this.ohlcvs[symbol]) {
             delete this.ohlcvs[symbol][timeframe];
         }
-        const error = new UnsubscribeError(this.id + ' ' + subMessageHash);
-        client.reject(error, subMessageHash);
-        client.resolve(true, messageHash);
     }
     handleUnsubscriptionTicker(client, symbol, channel) {
         const subMessageHash = channel + '::' + symbol;
         const messageHash = 'unsubscribe:ticker:' + symbol;
-        if (subMessageHash in client.subscriptions) {
-            delete client.subscriptions[subMessageHash];
-        }
-        if (messageHash in client.subscriptions) {
-            delete client.subscriptions[messageHash];
-        }
+        this.cleanUnsubscription(client, subMessageHash, messageHash);
         if (symbol in this.tickers) {
             delete this.tickers[symbol];
         }
-        const error = new UnsubscribeError(this.id + ' ' + subMessageHash);
-        client.reject(error, subMessageHash);
-        client.resolve(true, messageHash);
     }
     handleUnsubscription(client, message) {
         //

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

@@ -18,6 +18,9 @@ export default class oxfun extends oxfunRest {
     watchTicker(symbol: string, params?: {}): Promise<Ticker>;
     watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     handleTicker(client: Client, message: any): void;
+    watchBidsAsks(symbols?: Strings, params?: {}): Promise<Tickers>;
+    handleBidAsk(client: Client, message: any): void;
+    parseWsBidAsk(ticker: any, market?: any): Ticker;
     watchBalance(params?: {}): Promise<Balances>;
     handleBalance(client: any, message: any): void;
     watchPositions(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<Position[]>;

package/js/src/pro/oxfun.js

@@ -25,6 +25,7 @@ export default class oxfun extends oxfunRest {
                 'watchMyTrades': false,
                 'watchTicker': true,
                 'watchTickers': true,
+                'watchBidsAsks': true,
                 'watchBalance': true,
                 'createOrderWs': true,
                 'editOrderWs': true,
@@ -499,6 +500,77 @@ export default class oxfun extends oxfunRest {
             client.resolve(ticker, messageHash);
         }
     }
+    async watchBidsAsks(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name oxfun#watchBidsAsks
+         * @see https://docs.ox.fun/?json#best-bid-ask
+         * @description watches best bid & ask for symbols
+         * @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 messageHashes = [];
+        const args = [];
+        for (let i = 0; i < symbols.length; i++) {
+            const market = this.market(symbols[i]);
+            args.push('bestBidAsk:' + market['id']);
+            messageHashes.push('bidask:' + market['symbol']);
+        }
+        const newTickers = await this.subscribeMultiple(messageHashes, args, params);
+        if (this.newUpdates) {
+            const tickers = {};
+            tickers[newTickers['symbol']] = newTickers;
+            return tickers;
+        }
+        return this.filterByArray(this.bidsasks, 'symbol', symbols);
+    }
+    handleBidAsk(client, message) {
+        //
+        //     {
+        //       "table": "bestBidAsk",
+        //       "data": {
+        //         "ask": [
+        //           19045.0,
+        //           1.0
+        //         ],
+        //         "checksum": 3790706311,
+        //         "marketCode": "BTC-USD-SWAP-LIN",
+        //         "bid": [
+        //           19015.0,
+        //           1.0
+        //         ],
+        //         "timestamp": "1665456882928"
+        //       }
+        //     }
+        //
+        const data = this.safeDict(message, 'data', {});
+        const parsedTicker = this.parseWsBidAsk(data);
+        const symbol = parsedTicker['symbol'];
+        this.bidsasks[symbol] = parsedTicker;
+        const messageHash = 'bidask:' + symbol;
+        client.resolve(parsedTicker, messageHash);
+    }
+    parseWsBidAsk(ticker, market = undefined) {
+        const marketId = this.safeString(ticker, 'marketCode');
+        market = this.safeMarket(marketId, market);
+        const symbol = this.safeString(market, 'symbol');
+        const timestamp = this.safeInteger(ticker, 'timestamp');
+        const ask = this.safeList(ticker, 'ask', []);
+        const bid = this.safeList(ticker, 'bid', []);
+        return this.safeTicker({
+            'symbol': symbol,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'ask': this.safeNumber(ask, 0),
+            'askVolume': this.safeNumber(ask, 1),
+            'bid': this.safeNumber(bid, 0),
+            'bidVolume': this.safeNumber(bid, 1),
+            'info': ticker,
+        }, market);
+    }
     async watchBalance(params = {}) {
         /**
          * @method
@@ -1022,6 +1094,9 @@ export default class oxfun extends oxfunRest {
             if (table.indexOf('order') > -1) {
                 this.handleOrders(client, message);
             }
+            if (table === 'bestBidAsk') {
+                this.handleBidAsk(client, message);
+            }
         }
         else {
             if (event === 'login') {

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

@@ -1,5 +1,5 @@
 import phemexRest from '../phemex.js';
-import type { Int, Str, OrderBook, Order, Trade, Ticker, OHLCV, Balances, Dict } from '../base/types.js';
+import type { Int, Str, OrderBook, Order, Trade, Ticker, OHLCV, Balances, Dict, Strings, Tickers } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class phemex extends phemexRest {
     describe(): any;
@@ -16,6 +16,7 @@ export default class phemex extends phemexRest {
     handleTrades(client: Client, message: any): void;
     handleOHLCV(client: Client, message: any): void;
     watchTicker(symbol: string, params?: {}): Promise<Ticker>;
+    watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;

package/js/src/pro/phemex.js

@@ -17,7 +17,7 @@ export default class phemex extends phemexRest {
             'has': {
                 'ws': true,
                 'watchTicker': true,
-                'watchTickers': false,
+                'watchTickers': true,
                 'watchTrades': true,
                 'watchMyTrades': true,
                 'watchOrders': true,
@@ -526,6 +526,50 @@ export default class phemex extends phemexRest {
         const request = this.deepExtend(subscribe, params);
         return await this.watch(url, messageHash, request, subscriptionHash);
     }
+    async watchTickers(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name phemex#watchTickers
+         * @see https://github.com/phemex/phemex-api-docs/blob/master/Public-Hedged-Perpetual-API.md#subscribe-24-hours-ticker
+         * @see https://github.com/phemex/phemex-api-docs/blob/master/Public-Contract-API-en.md#subscribe-24-hours-ticker
+         * @see https://github.com/phemex/phemex-api-docs/blob/master/Public-Spot-API-en.md#subscribe-24-hours-ticker
+         * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
+         * @param {string[]} [symbols] unified symbol of the market to fetch the ticker for
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {string} [params.channel] the channel to subscribe to, tickers by default. Can be tickers, sprd-tickers, index-tickers, block-tickers
+         * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+         */
+        await this.loadMarkets();
+        symbols = this.marketSymbols(symbols, undefined, false);
+        const first = symbols[0];
+        const market = this.market(first);
+        const isSwap = market['swap'];
+        const settleIsUSDT = market['settle'] === 'USDT';
+        let name = 'spot_market24h';
+        if (isSwap) {
+            name = settleIsUSDT ? 'perp_market24h_pack_p' : 'market24h';
+        }
+        const url = this.urls['api']['ws'];
+        const requestId = this.requestId();
+        const subscriptionHash = name + '.subscribe';
+        const messageHashes = [];
+        for (let i = 0; i < symbols.length; i++) {
+            messageHashes.push('ticker:' + symbols[i]);
+        }
+        const subscribe = {
+            'method': subscriptionHash,
+            'id': requestId,
+            'params': [],
+        };
+        const request = this.deepExtend(subscribe, params);
+        const ticker = await this.watchMultiple(url, messageHashes, request, messageHashes);
+        if (this.newUpdates) {
+            const result = {};
+            result[ticker['symbol']] = ticker;
+            return result;
+        }
+        return this.filterByArray(this.tickers, 'symbol', symbols);
+    }
     async watchTrades(symbol, since = undefined, limit = undefined, params = {}) {
         /**
          * @method

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

@@ -12,6 +12,9 @@ export default class woofipro extends woofiproRest {
     handleTicker(client: Client, message: any): any;
     watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     handleTickers(client: Client, message: any): void;
+    watchBidsAsks(symbols?: Strings, params?: {}): Promise<Tickers>;
+    handleBidAsk(client: Client, message: any): void;
+    parseWsBidAsk(ticker: any, market?: any): Ticker;
     watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     handleOHLCV(client: Client, message: any): void;
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;