ccxt 4.4.1__py2.py3-none-any.whl → 4.4.3__py2.py3-none-any.whl

ccxt/pro/kucoin.py

@@ -11,7 +11,6 @@ from typing import List
 from typing import Any
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import ArgumentsRequired
-from ccxt.base.errors import UnsubscribeError
 
 
 class kucoin(ccxt.async_support.kucoin):
@@ -502,8 +501,6 @@ class kucoin(ccxt.async_support.kucoin):
         unWatches trades stream
         :see: https://www.kucoin.com/docs/websocket/spot-trading/public-channels/match-execution-data
         :param str symbol: unified symbol of the market to fetch trades for
-        :param int [since]: timestamp in ms of the earliest trade to fetch
-        :param int [limit]: the maximum amount of trades to fetch
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=public-trades>`
         """
@@ -851,46 +848,8 @@ class kucoin(ccxt.async_support.kucoin):
             for i in range(0, len(messageHashes)):
                 messageHash = messageHashes[i]
                 subHash = subMessageHashes[i]
-                if messageHash in client.subscriptions:
-                    del client.subscriptions[messageHash]
-                if subHash in client.subscriptions:
-                    del client.subscriptions[subHash]
-                error = UnsubscribeError(self.id + ' ' + subHash)
-                client.reject(error, subHash)
-                client.resolve(True, messageHash)
-                self.clean_cache(subscription)
-
-    def clean_cache(self, subscription: dict):
-        topic = self.safe_string(subscription, 'topic')
-        symbols = self.safe_list(subscription, 'symbols', [])
-        symbolsLength = len(symbols)
-        if symbolsLength > 0:
-            for i in range(0, len(symbols)):
-                symbol = symbols[i]
-                if topic == 'trades':
-                    if symbol in self.trades:
-                        del self.trades[symbol]
-                elif topic == 'orderbook':
-                    if symbol in self.orderbooks:
-                        del self.orderbooks[symbol]
-                elif topic == 'ticker':
-                    if symbol in self.tickers:
-                        del self.tickers[symbol]
-        else:
-            if topic == 'myTrades':
-                # don't reset self.myTrades directly here
-                # because in c# we need to use a different object
-                keys = list(self.myTrades.keys())
-                for i in range(0, len(keys)):
-                    del self.myTrades[keys[i]]
-            elif topic == 'orders':
-                orderSymbols = list(self.orders.keys())
-                for i in range(0, len(orderSymbols)):
-                    del self.orders[orderSymbols[i]]
-            elif topic == 'ticker':
-                tickerSymbols = list(self.tickers.keys())
-                for i in range(0, len(tickerSymbols)):
-                    del self.tickers[tickerSymbols[i]]
+                self.clean_unsubscription(client, subHash, messageHash)
+            self.clean_cache(subscription)
 
     def handle_system_status(self, client: Client, message):
         #

ccxt/pro/kucoinfutures.py

@@ -8,6 +8,7 @@ from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById,
 from ccxt.base.types import Balances, Int, Order, OrderBook, Position, Str, Strings, Ticker, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
+from typing import Any
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import ArgumentsRequired
 
@@ -175,6 +176,24 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
         }
         return await self.watch_multiple(url, messageHashes, self.extend(request, params), subscriptionHashes, subscriptionArgs)
 
+    async def un_subscribe_multiple(self, url, messageHashes, topic, subscriptionHashes, params={}, subscription: dict = None):
+        requestId = str(self.request_id())
+        request: dict = {
+            'id': requestId,
+            'type': 'unsubscribe',
+            'topic': topic,
+            'response': True,
+        }
+        message = self.extend(request, params)
+        if subscription is not None:
+            subscription[requestId] = requestId
+        client = self.client(url)
+        for i in range(0, len(subscriptionHashes)):
+            subscriptionHash = subscriptionHashes[i]
+            if not (subscriptionHash in client.subscriptions):
+                client.subscriptions[requestId] = subscriptionHash
+        return await self.watch_multiple(url, messageHashes, message, subscriptionHashes, subscription)
+
     async def watch_ticker(self, symbol: str, params={}) -> Ticker:
         """
         watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
@@ -526,6 +545,44 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
             limit = trades.getLimit(tradeSymbol, limit)
         return self.filter_by_since_limit(trades, since, limit, 'timestamp', True)
 
+    async def un_watch_trades(self, symbol: str, params={}) -> Any:
+        """
+        unWatches trades stream
+        :see: https://docs.kucoin.com/futures/#execution-data
+        :param str symbol: unified symbol of the market to fetch trades for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=public-trades>`
+        """
+        return await self.un_watch_trades_for_symbols([symbol], params)
+
+    async def un_watch_trades_for_symbols(self, symbols: List[str], params={}) -> Any:
+        """
+        get the list of most recent trades for a particular symbol
+        :param str symbol: unified symbol of the market to fetch trades for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict[]: a list of `trade structures <https://docs.ccxt.com/#/?id=public-trades>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, False)
+        url = await self.negotiate(False)
+        symbols = self.market_symbols(symbols)
+        marketIds = self.market_ids(symbols)
+        topic = '/contractMarket/execution:' + ','.join(marketIds)
+        subscriptionHashes = []
+        messageHashes = []
+        for i in range(0, len(symbols)):
+            symbol = symbols[i]
+            messageHashes.append('unsubscribe:trades:' + symbol)
+            subscriptionHashes.append('trades:' + symbol)
+        subscription = {
+            'messageHashes': messageHashes,
+            'subMessageHashes': subscriptionHashes,
+            'topic': 'trades',
+            'unsubscribe': True,
+            'symbols': symbols,
+        }
+        return await self.un_subscribe_multiple(url, messageHashes, topic, messageHashes, params, subscription)
+
     def handle_trade(self, client: Client, message):
         #
         #    {
@@ -651,6 +708,7 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
     async def watch_order_book_for_symbols(self, symbols: List[str], limit: Int = None, params={}) -> OrderBook:
         """
         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 str[] symbols: unified array of symbols
         :param int [limit]: the maximum amount of order book entries to return
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -680,6 +738,43 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
         orderbook = await self.subscribe_multiple(url, messageHashes, topic, subscriptionHashes, subscriptionArgs, params)
         return orderbook.limit()
 
+    async def un_watch_order_book(self, symbol: str, params={}) -> Any:
+        """
+        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 str symbol: unified symbol of the market to fetch the order book for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
+        """
+        return await self.un_watch_order_book_for_symbols([symbol], params)
+
+    async def un_watch_order_book_for_symbols(self, symbols: List[str], params={}) -> Any:
+        """
+        unWatches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
+        :param str[] symbols: unified array of symbols
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols)
+        marketIds = self.market_ids(symbols)
+        url = await self.negotiate(False)
+        topic = '/contractMarket/level2:' + ','.join(marketIds)
+        subscriptionHashes = []
+        messageHashes = []
+        for i in range(0, len(symbols)):
+            symbol = symbols[i]
+            messageHashes.append('unsubscribe:orderbook:' + symbol)
+            subscriptionHashes.append('orderbook:' + symbol)
+        subscription = {
+            'messageHashes': messageHashes,
+            'symbols': symbols,
+            'unsubscribe': True,
+            'topic': 'orderbook',
+            'subMessageHashes': subscriptionHashes,
+        }
+        return await self.un_subscribe_multiple(url, messageHashes, topic, messageHashes, params, subscription)
+
     def handle_delta(self, orderbook, delta):
         orderbook['nonce'] = self.safe_integer(delta, 'sequence')
         timestamp = self.safe_integer(delta, 'timestamp')
@@ -1067,6 +1162,32 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
             self.options['urls'][type] = None
         self.handle_errors(None, None, client.url, None, None, data, message, None, None)
 
+    def handle_subscription_status(self, client: Client, message):
+        #
+        #     {
+        #         "id": "1578090438322",
+        #         "type": "ack"
+        #     }
+        #
+        id = self.safe_string(message, 'id')
+        if not (id in client.subscriptions):
+            return
+        subscriptionHash = self.safe_string(client.subscriptions, id)
+        subscription = self.safe_value(client.subscriptions, subscriptionHash)
+        del client.subscriptions[id]
+        method = self.safe_value(subscription, 'method')
+        if method is not None:
+            method(client, message, subscription)
+        isUnSub = self.safe_bool(subscription, 'unsubscribe', False)
+        if isUnSub:
+            messageHashes = self.safe_list(subscription, 'messageHashes', [])
+            subMessageHashes = self.safe_list(subscription, 'subMessageHashes', [])
+            for i in range(0, len(messageHashes)):
+                messageHash = messageHashes[i]
+                subHash = subMessageHashes[i]
+                self.clean_unsubscription(client, subHash, messageHash)
+            self.clean_cache(subscription)
+
     def handle_message(self, client: Client, message):
         type = self.safe_string(message, 'type')
         methods: dict = {
@@ -1075,6 +1196,7 @@ class kucoinfutures(ccxt.async_support.kucoinfutures):
             'message': self.handle_subject,
             'pong': self.handle_pong,
             'error': self.handle_error_message,
+            'ack': self.handle_subscription_status,
         }
         method = self.safe_value(methods, type)
         if method is not None:

ccxt/pro/mexc.py

@@ -6,7 +6,7 @@
 import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheByTimestamp
 import hashlib
-from ccxt.base.types import Balances, Int, Order, OrderBook, Str, Ticker, Trade
+from ccxt.base.types import Balances, Int, Order, OrderBook, Str, Strings, Ticker, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import AuthenticationError
@@ -33,7 +33,7 @@ class mexc(ccxt.async_support.mexc):
                 'watchOrderBook': True,
                 'watchOrders': True,
                 'watchTicker': True,
-                'watchTickers': False,
+                'watchTickers': True,
                 'watchTrades': True,
                 'watchTradesForSymbols': False,
             },
@@ -126,6 +126,77 @@ class mexc(ccxt.async_support.mexc):
         messageHash = 'ticker:' + symbol
         client.resolve(ticker, messageHash)
 
+    async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+        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 str[] symbols: unified symbol of the market to fetch the ticker for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, False)
+        messageHashes = []
+        marketIds = self.market_ids(symbols)
+        firstMarket = self.market(symbols[0])
+        isSpot = firstMarket['spot']
+        url = self.urls['api']['ws']['spot'] if (isSpot) else self.urls['api']['ws']['swap']
+        request: dict = {}
+        if isSpot:
+            topics = []
+            for i in range(0, len(marketIds)):
+                marketId = marketIds[i]
+                messageHashes.append('ticker:' + symbols[i])
+                topics.append('spot@public.bookTicker.v3.api@' + marketId)
+            request['method'] = 'SUBSCRIPTION'
+            request['params'] = topics
+        else:
+            request['method'] = 'sub.tickers'
+            request['params'] = {}
+            messageHashes.append('ticker')
+        ticker = await self.watch_multiple(url, messageHashes, self.extend(request, params), messageHashes)
+        if isSpot and self.newUpdates:
+            result: dict = {}
+            result[ticker['symbol']] = ticker
+            return result
+        return self.filter_by_array(self.tickers, 'symbol', symbols)
+
+    def handle_tickers(self, client: 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
+        #     }
+        #
+        data = self.safe_list(message, 'data')
+        topic = 'ticker'
+        result = []
+        for i in range(0, len(data)):
+            ticker = self.parse_ticker(data[i])
+            symbol = ticker['symbol']
+            self.tickers[symbol] = ticker
+            result.append(ticker)
+            messageHash = topic + ':' + symbol
+            client.resolve(ticker, messageHash)
+        client.resolve(result, topic)
+
     def parse_ws_ticker(self, ticker, market=None):
         #
         # spot
@@ -1073,8 +1144,8 @@ class mexc(ccxt.async_support.mexc):
         #        "code": 0,
         #        "msg": "spot@public.increase.depth.v3.api@BTCUSDT"
         #    }
-        #
-        msg = self.safe_string(message, 'msg')
+        # Set the default to an empty string if the message is empty during the test.
+        msg = self.safe_string(message, 'msg', '')
         if msg == 'PONG':
             self.handle_pong(client, message)
         elif msg.find('@') > -1:
@@ -1110,6 +1181,7 @@ class mexc(ccxt.async_support.mexc):
             'push.kline': self.handle_ohlcv,
             'public.bookTicker.v3.api': self.handle_ticker,
             'push.ticker': self.handle_ticker,
+            'push.tickers': self.handle_tickers,
             'public.increase.depth.v3.api': self.handle_order_book,
             'push.depth': self.handle_order_book,
             'private.orders.v3.api': self.handle_order,

ccxt/pro/okx.py

@@ -16,7 +16,6 @@ from ccxt.base.errors import ArgumentsRequired
 from ccxt.base.errors import BadRequest
 from ccxt.base.errors import InvalidNonce
 from ccxt.base.errors import ChecksumError
-from ccxt.base.errors import UnsubscribeError
 
 
 class okx(ccxt.async_support.okx):
@@ -1341,8 +1340,10 @@ class okx(ccxt.async_support.okx):
                     },
                 ],
             }
-            message = self.extend(request, params)
-            self.watch(url, messageHash, message, messageHash)
+            # Only add params['access'] to prevent sending custom parameters, such.
+            if 'access' in params:
+                request['access'] = params['access']
+            self.watch(url, messageHash, request, messageHash)
         return await future
 
     async def watch_balance(self, params={}) -> Balances:
@@ -1500,7 +1501,7 @@ class okx(ccxt.async_support.okx):
                 'channel': 'positions',
                 'instType': 'ANY',
             }
-            args = [arg]
+            args = [self.extend(arg, params)]
             nonSymbolRequest: dict = {
                 'op': 'subscribe',
                 'args': args,
@@ -2162,54 +2163,32 @@ class okx(ccxt.async_support.okx):
     def handle_un_subscription_trades(self, client: Client, symbol: str):
         subMessageHash = 'trades:' + symbol
         messageHash = 'unsubscribe:trades:' + symbol
-        if subMessageHash in client.subscriptions:
-            del client.subscriptions[subMessageHash]
-        if messageHash in client.subscriptions:
-            del client.subscriptions[messageHash]
-        del self.trades[symbol]
-        error = UnsubscribeError(self.id + ' ' + subMessageHash)
-        client.reject(error, subMessageHash)
-        client.resolve(True, messageHash)
+        self.clean_unsubscription(client, subMessageHash, messageHash)
+        if symbol in self.trades:
+            del self.trades[symbol]
 
     def handle_unsubscription_order_book(self, client: Client, symbol: str, channel: str):
         subMessageHash = channel + ':' + symbol
         messageHash = 'unsubscribe:orderbook:' + symbol
-        if subMessageHash in client.subscriptions:
-            del client.subscriptions[subMessageHash]
-        if messageHash in client.subscriptions:
-            del client.subscriptions[messageHash]
-        del self.orderbooks[symbol]
-        error = UnsubscribeError(self.id + ' ' + subMessageHash)
-        client.reject(error, subMessageHash)
-        client.resolve(True, messageHash)
+        self.clean_unsubscription(client, subMessageHash, messageHash)
+        if symbol in self.orderbooks:
+            del self.orderbooks[symbol]
 
     def handle_unsubscription_ohlcv(self, client: Client, symbol: str, channel: str):
         tf = channel.replace('candle', '')
         timeframe = self.find_timeframe(tf)
         subMessageHash = 'multi:' + channel + ':' + symbol
         messageHash = 'unsubscribe:' + subMessageHash
-        if subMessageHash in client.subscriptions:
-            del client.subscriptions[subMessageHash]
-        if messageHash in client.subscriptions:
-            del client.subscriptions[messageHash]
+        self.clean_unsubscription(client, subMessageHash, messageHash)
         if timeframe in self.ohlcvs[symbol]:
             del self.ohlcvs[symbol][timeframe]
-        error = UnsubscribeError(self.id + ' ' + subMessageHash)
-        client.reject(error, subMessageHash)
-        client.resolve(True, messageHash)
 
     def handle_unsubscription_ticker(self, client: Client, symbol: str, channel):
         subMessageHash = channel + '::' + symbol
         messageHash = 'unsubscribe:ticker:' + symbol
-        if subMessageHash in client.subscriptions:
-            del client.subscriptions[subMessageHash]
-        if messageHash in client.subscriptions:
-            del client.subscriptions[messageHash]
+        self.clean_unsubscription(client, subMessageHash, messageHash)
         if symbol in self.tickers:
             del self.tickers[symbol]
-        error = UnsubscribeError(self.id + ' ' + subMessageHash)
-        client.reject(error, subMessageHash)
-        client.resolve(True, messageHash)
 
     def handle_unsubscription(self, client: Client, message):
         #

ccxt/pro/oxfun.py

@@ -30,6 +30,7 @@ class oxfun(ccxt.async_support.oxfun):
                 'watchMyTrades': False,
                 'watchTicker': True,
                 'watchTickers': True,
+                'watchBidsAsks': True,
                 'watchBalance': True,
                 'createOrderWs': True,
                 'editOrderWs': True,
@@ -466,6 +467,73 @@ class oxfun(ccxt.async_support.oxfun):
             self.tickers[symbol] = ticker
             client.resolve(ticker, messageHash)
 
+    async def watch_bids_asks(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+        :see: https://docs.ox.fun/?json#best-bid-ask
+        watches best bid & ask for symbols
+        :param str[] symbols: unified symbol of the market to fetch the ticker for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, False)
+        messageHashes = []
+        args = []
+        for i in range(0, len(symbols)):
+            market = self.market(symbols[i])
+            args.append('bestBidAsk:' + market['id'])
+            messageHashes.append('bidask:' + market['symbol'])
+        newTickers = await self.subscribe_multiple(messageHashes, args, params)
+        if self.newUpdates:
+            tickers: dict = {}
+            tickers[newTickers['symbol']] = newTickers
+            return tickers
+        return self.filter_by_array(self.bidsasks, 'symbol', symbols)
+
+    def handle_bid_ask(self, client: Client, message):
+        #
+        #     {
+        #       "table": "bestBidAsk",
+        #       "data": {
+        #         "ask": [
+        #           19045.0,
+        #           1.0
+        #         ],
+        #         "checksum": 3790706311,
+        #         "marketCode": "BTC-USD-SWAP-LIN",
+        #         "bid": [
+        #           19015.0,
+        #           1.0
+        #         ],
+        #         "timestamp": "1665456882928"
+        #       }
+        #     }
+        #
+        data = self.safe_dict(message, 'data', {})
+        parsedTicker = self.parse_ws_bid_ask(data)
+        symbol = parsedTicker['symbol']
+        self.bidsasks[symbol] = parsedTicker
+        messageHash = 'bidask:' + symbol
+        client.resolve(parsedTicker, messageHash)
+
+    def parse_ws_bid_ask(self, ticker, market=None):
+        marketId = self.safe_string(ticker, 'marketCode')
+        market = self.safe_market(marketId, market)
+        symbol = self.safe_string(market, 'symbol')
+        timestamp = self.safe_integer(ticker, 'timestamp')
+        ask = self.safe_list(ticker, 'ask', [])
+        bid = self.safe_list(ticker, 'bid', [])
+        return self.safe_ticker({
+            'symbol': symbol,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'ask': self.safe_number(ask, 0),
+            'askVolume': self.safe_number(ask, 1),
+            'bid': self.safe_number(bid, 0),
+            'bidVolume': self.safe_number(bid, 1),
+            'info': ticker,
+        }, market)
+
     async def watch_balance(self, params={}) -> Balances:
         """
         :see: https://docs.ox.fun/?json#balance-channel
@@ -943,6 +1011,8 @@ class oxfun(ccxt.async_support.oxfun):
                 self.handle_positions(client, message)
             if table.find('order') > -1:
                 self.handle_orders(client, message)
+            if table == 'bestBidAsk':
+                self.handle_bid_ask(client, message)
         else:
             if event == 'login':
                 self.handle_authentication_message(client, message)

ccxt/pro/phemex.py

@@ -6,7 +6,7 @@
 import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheByTimestamp
 import hashlib
-from ccxt.base.types import Balances, Int, Order, OrderBook, Str, Ticker, Trade
+from ccxt.base.types import Balances, Int, Order, OrderBook, Str, Strings, Ticker, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import AuthenticationError
@@ -20,7 +20,7 @@ class phemex(ccxt.async_support.phemex):
             'has': {
                 'ws': True,
                 'watchTicker': True,
-                'watchTickers': False,  # for now
+                'watchTickers': True,
                 'watchTrades': True,
                 'watchMyTrades': True,
                 'watchOrders': True,
@@ -504,6 +504,45 @@ class phemex(ccxt.async_support.phemex):
         request = self.deep_extend(subscribe, params)
         return await self.watch(url, messageHash, request, subscriptionHash)
 
+    async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+        :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
+        watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
+        :param str[] [symbols]: unified symbol of the market to fetch the ticker for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.channel]: the channel to subscribe to, tickers by default. Can be tickers, sprd-tickers, index-tickers, block-tickers
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, False)
+        first = symbols[0]
+        market = self.market(first)
+        isSwap = market['swap']
+        settleIsUSDT = market['settle'] == 'USDT'
+        name = 'spot_market24h'
+        if isSwap:
+            name = 'perp_market24h_pack_p' if settleIsUSDT else 'market24h'
+        url = self.urls['api']['ws']
+        requestId = self.request_id()
+        subscriptionHash = name + '.subscribe'
+        messageHashes = []
+        for i in range(0, len(symbols)):
+            messageHashes.append('ticker:' + symbols[i])
+        subscribe: dict = {
+            'method': subscriptionHash,
+            'id': requestId,
+            'params': [],
+        }
+        request = self.deep_extend(subscribe, params)
+        ticker = await self.watch_multiple(url, messageHashes, request, messageHashes)
+        if self.newUpdates:
+            result: dict = {}
+            result[ticker['symbol']] = ticker
+            return result
+        return self.filter_by_array(self.tickers, 'symbol', symbols)
+
     async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         :see: https://github.com/phemex/phemex-api-docs/blob/master/Public-Hedged-Perpetual-API.md#subscribe-trade