ccxt 4.4.8__py2.py3-none-any.whl → 4.4.10__py2.py3-none-any.whl

ccxt/phemex.py

@@ -7,7 +7,7 @@ from ccxt.base.exchange import Exchange
 from ccxt.abstract.phemex import ImplicitAPI
 import hashlib
 import numbers
-from ccxt.base.types import Balances, Currencies, Currency, Int, LeverageTier, LeverageTiers, MarginModification, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction, TransferEntry
+from ccxt.base.types import Balances, Currencies, Currency, Int, LeverageTier, LeverageTiers, MarginModification, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, FundingRate, Trade, Transaction, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
@@ -3741,7 +3741,7 @@ class phemex(Exchange, ImplicitAPI):
             value = Precise.string_mul(value, tickPrecision)
         return value
 
-    def fetch_funding_rate(self, symbol: str, params={}):
+    def fetch_funding_rate(self, symbol: str, params={}) -> FundingRate:
         """
         fetch the current funding rate
         :param str symbol: unified market symbol
@@ -3786,7 +3786,7 @@ class phemex(Exchange, ImplicitAPI):
         result = self.safe_value(response, 'result', {})
         return self.parse_funding_rate(result, market)
 
-    def parse_funding_rate(self, contract, market: Market = None):
+    def parse_funding_rate(self, contract, market: Market = None) -> FundingRate:
         #
         #     {
         #         "askEp": 2332500,
@@ -3845,6 +3845,7 @@ class phemex(Exchange, ImplicitAPI):
             'previousFundingRate': None,
             'previousFundingTimestamp': None,
             'previousFundingDatetime': None,
+            'interval': None,
         }
 
     def set_margin(self, symbol: str, amount: float, params={}) -> MarginModification:

ccxt/poloniexfutures.py

@@ -6,7 +6,7 @@
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.poloniexfutures import ImplicitAPI
 import hashlib
-from ccxt.base.types import Balances, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade
+from ccxt.base.types import Balances, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, FundingRate, Trade
 from typing import List
 from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import AccountSuspended
@@ -1527,7 +1527,7 @@ class poloniexfutures(Exchange, ImplicitAPI):
             'trades': None,
         }, market)
 
-    def fetch_funding_rate(self, symbol: str, params={}):
+    def fetch_funding_rate(self, symbol: str, params={}) -> FundingRate:
         """
         fetch the current funding rate
         :see: https://api-docs.poloniex.com/futures/api/futures-index#get-premium-index
@@ -1571,8 +1571,19 @@ class poloniexfutures(Exchange, ImplicitAPI):
             'previousFundingRate': self.safe_number(data, 'value'),
             'previousFundingTimestamp': fundingTimestamp,
             'previousFundingDatetime': self.iso8601(fundingTimestamp),
+            'interval': self.parse_funding_interval(self.safe_string(data, 'interval')),
         }
 
+    def parse_funding_interval(self, interval):
+        intervals: dict = {
+            '3600000': '1h',
+            '14400000': '4h',
+            '28800000': '8h',
+            '57600000': '16h',
+            '86400000': '24h',
+        }
+        return self.safe_string(intervals, interval, interval)
+
     def fetch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}):
         """
         fetch all trades made by the user

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.4.8'
+__version__ = '4.4.10'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/binance.py

@@ -2417,13 +2417,13 @@ class binance(ccxt.async_support.binance):
         subType, params = self.handle_sub_type_and_params('watchBalance', None, params)
         isPortfolioMargin = None
         isPortfolioMargin, params = self.handle_option_and_params_2(params, 'watchBalance', 'papi', 'portfolioMargin', False)
-        urlType = type
-        if isPortfolioMargin:
-            urlType = 'papi'
         if self.isLinear(type, subType):
             type = 'future'
         elif self.isInverse(type, subType):
             type = 'delivery'
+        urlType = type
+        if isPortfolioMargin:
+            urlType = 'papi'
         url = self.urls['api']['ws'][urlType] + '/' + self.options[type]['listenKey']
         client = self.client(url)
         self.set_balance_cache(client, type, isPortfolioMargin)

ccxt/pro/deribit.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 ExchangeError
@@ -22,7 +22,7 @@ class deribit(ccxt.async_support.deribit):
                 'ws': True,
                 'watchBalance': True,
                 'watchTicker': True,
-                'watchTickers': False,
+                'watchTickers': True,
                 'watchTrades': True,
                 'watchTradesForSymbols': True,
                 'watchMyTrades': True,
@@ -189,6 +189,43 @@ class deribit(ccxt.async_support.deribit):
         request = self.deep_extend(message, params)
         return await self.watch(url, channel, request, channel, request)
 
+    async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+        :see: https://docs.deribit.com/#ticker-instrument_name-interval
+        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.interval]: specify aggregation and frequency of notifications. Possible values: 100ms, raw
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, False)
+        url = self.urls['api']['ws']
+        interval = self.safe_string(params, 'interval', '100ms')
+        params = self.omit(params, 'interval')
+        await self.load_markets()
+        if interval == 'raw':
+            await self.authenticate()
+        channels = []
+        for i in range(0, len(symbols)):
+            market = self.market(symbols[i])
+            channels.append('ticker.' + market['id'] + '.' + interval)
+        message: dict = {
+            'jsonrpc': '2.0',
+            'method': 'public/subscribe',
+            'params': {
+                'channels': channels,
+            },
+            'id': self.request_id(),
+        }
+        request = self.deep_extend(message, params)
+        newTickers = await self.watch_multiple(url, channels, request, channels, request)
+        if self.newUpdates:
+            tickers: dict = {}
+            tickers[newTickers['symbol']] = newTickers
+            return tickers
+        return self.filter_by_array(self.tickers, 'symbol', symbols)
+
     def handle_ticker(self, client: Client, message):
         #
         #     {

ccxt/pro/gate.py

@@ -332,7 +332,7 @@ class gate(ccxt.async_support.gate):
             symbol = market['symbol']
             if market['swap'] is not True:
                 raise NotSupported(self.id + ' fetchOrdersByStatusWs is only supported by swap markets. Use rest API for other markets')
-        request, requestParams = self.fetchOrdersByStatusRequest(status, symbol, since, limit, params)
+        request, requestParams = self.prepareOrdersByStatusRequest(status, symbol, since, limit, params)
         newRequest = self.omit(request, ['settle'])
         messageType = self.get_type_by_market(market)
         channel = messageType + '.order_list'

ccxt/pro/hitbtc.py

@@ -22,6 +22,7 @@ class hitbtc(ccxt.async_support.hitbtc):
                 'ws': True,
                 'watchTicker': True,
                 'watchTickers': True,
+                'watchBidsAsks': True,
                 'watchTrades': True,
                 'watchTradesForSymbols': False,
                 'watchOrderBook': True,
@@ -56,8 +57,11 @@ class hitbtc(ccxt.async_support.hitbtc):
                 'watchTickers': {
                     'method': 'ticker/{speed}',  # 'ticker/{speed}','ticker/price/{speed}', 'ticker/{speed}/batch', or 'ticker/{speed}/price/batch''
                 },
+                'watchBidsAsks': {
+                    'method': 'orderbook/top/{speed}',  # 'orderbook/top/{speed}', 'orderbook/top/{speed}/batch'
+                },
                 'watchOrderBook': {
-                    'method': 'orderbook/full',  # 'orderbook/full', 'orderbook/{depth}/{speed}', 'orderbook/{depth}/{speed}/batch', 'orderbook/top/{speed}', or 'orderbook/top/{speed}/batch'
+                    'method': 'orderbook/full',  # 'orderbook/full', 'orderbook/{depth}/{speed}', 'orderbook/{depth}/{speed}/batch'
                 },
             },
             'timeframes': {
@@ -130,17 +134,22 @@ class hitbtc(ccxt.async_support.hitbtc):
         :param dict [params]: extra parameters specific to the hitbtc api
         """
         await self.load_markets()
+        symbols = self.market_symbols(symbols)
+        isBatch = name.find('batch') >= 0
         url = self.urls['api']['ws']['public']
-        messageHash = messageHashPrefix
-        if symbols is not None:
-            messageHash = messageHash + '::' + ','.join(symbols)
+        messageHashes = []
+        if symbols is not None and not isBatch:
+            for i in range(0, len(symbols)):
+                messageHashes.append(messageHashPrefix + '::' + symbols[i])
+        else:
+            messageHashes.append(messageHashPrefix)
         subscribe: dict = {
             'method': 'subscribe',
             'id': self.nonce(),
             'ch': name,
         }
         request = self.extend(subscribe, params)
-        return await self.watch(url, messageHash, request, messageHash)
+        return await self.watch_multiple(url, messageHashes, request, messageHashes)
 
     async def subscribe_private(self, name: str, symbol: Str = None, params={}):
         """
@@ -192,7 +201,7 @@ class hitbtc(ccxt.async_support.hitbtc):
         :param str symbol: unified symbol of the market to fetch the order book for
         :param int [limit]: the maximum amount of order book entries to return
         :param dict [params]: extra parameters specific to the exchange API endpoint
-        :param str [params.method]: 'orderbook/full', 'orderbook/{depth}/{speed}', 'orderbook/{depth}/{speed}/batch', 'orderbook/top/{speed}', or 'orderbook/top/{speed}/batch'
+        :param str [params.method]: 'orderbook/full', 'orderbook/{depth}/{speed}', 'orderbook/{depth}/{speed}/batch'
         :param int [params.depth]: 5 , 10, or 20(default)
         :param int [params.speed]: 100(default), 500, or 1000
         :returns dict: A dictionary of `order book structures <https://docs.ccxt.com/#/?id=order-book-structure>` indexed by market symbols
@@ -206,10 +215,6 @@ class hitbtc(ccxt.async_support.hitbtc):
             name = 'orderbook/D' + depth + '/' + speed + 'ms'
         elif name == 'orderbook/{depth}/{speed}/batch':
             name = 'orderbook/D' + depth + '/' + speed + 'ms/batch'
-        elif name == 'orderbook/top/{speed}':
-            name = 'orderbook/top/' + speed + 'ms'
-        elif name == 'orderbook/top/{speed}/batch':
-            name = 'orderbook/top/' + speed + 'ms/batch'
         market = self.market(symbol)
         request: dict = {
             'params': {
@@ -298,33 +303,22 @@ class hitbtc(ccxt.async_support.hitbtc):
         :param str [params.speed]: '1s'(default), or '3s'
         :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
         """
-        options = self.safe_value(self.options, 'watchTicker')
-        defaultMethod = self.safe_string(options, 'method', 'ticker/{speed}')
-        method = self.safe_string_2(params, 'method', 'defaultMethod', defaultMethod)
-        speed = self.safe_string(params, 'speed', '1s')
-        name = self.implode_params(method, {'speed': speed})
-        params = self.omit(params, ['method', 'speed'])
-        market = self.market(symbol)
-        request: dict = {
-            'params': {
-                'symbols': [market['id']],
-            },
-        }
-        result = await self.subscribe_public(name, 'tickers', [symbol], self.deep_extend(request, params))
-        return self.safe_value(result, symbol)
+        ticker = await self.watch_tickers([symbol], params)
+        return self.safe_value(ticker, symbol)
 
     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 a specific market
         :param str symbol: unified symbol of the market to fetch the ticker for
         :param dict params: extra parameters specific to the exchange API endpoint
-        :param str params['method']: 'ticker/{speed}'(default),'ticker/price/{speed}', 'ticker/{speed}/batch', or 'ticker/{speed}/price/batch''
+        :param str params['method']: 'ticker/{speed}' ,'ticker/price/{speed}', 'ticker/{speed}/batch'(default), or 'ticker/{speed}/price/batch''
         :param str params['speed']: '1s'(default), or '3s'
         :returns dict: a `ticker structure <https://docs.ccxt.com/en/latest/manual.html#ticker-structure>`
         """
         await self.load_markets()
+        symbols = self.market_symbols(symbols)
         options = self.safe_value(self.options, 'watchTicker')
-        defaultMethod = self.safe_string(options, 'method', 'ticker/{speed}')
+        defaultMethod = self.safe_string(options, 'method', 'ticker/{speed}/batch')
         method = self.safe_string_2(params, 'method', 'defaultMethod', defaultMethod)
         speed = self.safe_string(params, 'speed', '1s')
         name = self.implode_params(method, {'speed': speed})
@@ -341,10 +335,13 @@ class hitbtc(ccxt.async_support.hitbtc):
                 'symbols': marketIds,
             },
         }
-        tickers = await self.subscribe_public(name, 'tickers', symbols, self.deep_extend(request, params))
+        newTickers = await self.subscribe_public(name, 'tickers', symbols, self.deep_extend(request, params))
         if self.newUpdates:
-            return tickers
-        return self.filter_by_array(self.tickers, 'symbol', symbols)
+            if not isinstance(newTickers, list):
+                tickers: dict = {}
+                tickers[newTickers['symbol']] = newTickers
+                return tickers
+        return self.filter_by_array(newTickers, 'symbol', symbols)
 
     def handle_ticker(self, client: Client, message):
         #
@@ -387,27 +384,18 @@ class hitbtc(ccxt.async_support.hitbtc):
         #
         data = self.safe_value(message, 'data', {})
         marketIds = list(data.keys())
-        newTickers: dict = {}
+        result = []
+        topic = 'tickers'
         for i in range(0, len(marketIds)):
             marketId = marketIds[i]
             market = self.safe_market(marketId)
             symbol = market['symbol']
             ticker = self.parse_ws_ticker(data[marketId], market)
             self.tickers[symbol] = ticker
-            newTickers[symbol] = ticker
-        client.resolve(newTickers, 'tickers')
-        messageHashes = self.find_message_hashes(client, 'tickers::')
-        for i in range(0, len(messageHashes)):
-            messageHash = messageHashes[i]
-            parts = messageHash.split('::')
-            symbolsString = parts[1]
-            symbols = symbolsString.split(',')
-            tickers = self.filter_by_array(newTickers, 'symbol', symbols)
-            tickersSymbols = list(tickers.keys())
-            numTickers = len(tickersSymbols)
-            if numTickers > 0:
-                client.resolve(tickers, messageHash)
-        return message
+            result.append(ticker)
+            messageHash = topic + '::' + symbol
+            client.resolve(ticker, messageHash)
+        client.resolve(result, topic)
 
     def parse_ws_ticker(self, ticker, market=None):
         #
@@ -464,6 +452,81 @@ class hitbtc(ccxt.async_support.hitbtc):
             'info': ticker,
         }, market)
 
+    async def watch_bids_asks(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+        watches best bid & ask for symbols
+        :see: https://api.hitbtc.com/#subscribe-to-top-of-book
+        :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.method]: 'orderbook/top/{speed}' or 'orderbook/top/{speed}/batch(default)'
+        :param str [params.speed]: '100ms'(default) or '500ms' or '1000ms'
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, False)
+        options = self.safe_value(self.options, 'watchBidsAsks')
+        defaultMethod = self.safe_string(options, 'method', 'orderbook/top/{speed}/batch')
+        method = self.safe_string_2(params, 'method', 'defaultMethod', defaultMethod)
+        speed = self.safe_string(params, 'speed', '100ms')
+        name = self.implode_params(method, {'speed': speed})
+        params = self.omit(params, ['method', 'speed'])
+        marketIds = self.market_ids(symbols)
+        request: dict = {
+            'params': {
+                'symbols': marketIds,
+            },
+        }
+        newTickers = await self.subscribe_public(name, 'bidask', symbols, self.deep_extend(request, params))
+        if self.newUpdates:
+            if not isinstance(newTickers, list):
+                tickers: dict = {}
+                tickers[newTickers['symbol']] = newTickers
+                return tickers
+        return self.filter_by_array(newTickers, 'symbol', symbols)
+
+    def handle_bid_ask(self, client: Client, message):
+        #
+        #     {
+        #         "ch": "orderbook/top/100ms",  # or 'orderbook/top/100ms/batch'
+        #         "data": {
+        #             "BTCUSDT": {
+        #                 "t": 1727276919771,
+        #                 "a": "63931.45",
+        #                 "A": "0.02879",
+        #                 "b": "63926.97",
+        #                 "B": "0.00100"
+        #             }
+        #         }
+        #     }
+        #
+        data = self.safe_dict(message, 'data', {})
+        marketIds = list(data.keys())
+        result = []
+        topic = 'bidask'
+        for i in range(0, len(marketIds)):
+            marketId = marketIds[i]
+            market = self.safe_market(marketId)
+            symbol = market['symbol']
+            ticker = self.parse_ws_bid_ask(data[marketId], market)
+            self.bidsasks[symbol] = ticker
+            result.append(ticker)
+            messageHash = topic + '::' + symbol
+            client.resolve(ticker, messageHash)
+        client.resolve(result, topic)
+
+    def parse_ws_bid_ask(self, ticker, market=None):
+        timestamp = self.safe_integer(ticker, 't')
+        return self.safe_ticker({
+            'symbol': market['symbol'],
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'ask': self.safe_string(ticker, 'a'),
+            'askVolume': self.safe_string(ticker, 'A'),
+            'bid': self.safe_string(ticker, 'b'),
+            'bidVolume': self.safe_string(ticker, 'B'),
+            'info': ticker,
+        }, market)
+
     async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         get the list of most recent trades for a particular symbol
@@ -1144,11 +1207,16 @@ class hitbtc(ccxt.async_support.hitbtc):
         if channel is not None:
             splitChannel = channel.split('/')
             channel = self.safe_string(splitChannel, 0)
+            if channel == 'orderbook':
+                channel2 = self.safe_string(splitChannel, 1)
+                if channel2 is not None and channel2 == 'top':
+                    channel = 'orderbook/top'
             methods: dict = {
                 'candles': self.handle_ohlcv,
                 'ticker': self.handle_ticker,
                 'trades': self.handle_trades,
                 'orderbook': self.handle_order_book,
+                'orderbook/top': self.handle_bid_ask,
                 'spot_order': self.handle_order,
                 'spot_orders': self.handle_order,
                 'margin_order': self.handle_order,

ccxt/pro/hollaex.py

@@ -62,6 +62,7 @@ class hollaex(ccxt.async_support.hollaex):
     async def watch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
         watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
+        :see: https://apidocs.hollaex.com/#sending-receiving-messages
         :param str symbol: unified symbol of the market to fetch the order book for
         :param int [limit]: the maximum amount of order book entries to return
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -116,6 +117,7 @@ class hollaex(ccxt.async_support.hollaex):
     async def watch_trades(self, symbol: str, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         get the list of most recent trades for a particular symbol
+        :see: https://apidocs.hollaex.com/#sending-receiving-messages
         :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
@@ -167,6 +169,7 @@ class hollaex(ccxt.async_support.hollaex):
     async def watch_my_trades(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Trade]:
         """
         watches information on multiple trades made by the user
+        :see: https://apidocs.hollaex.com/#sending-receiving-messages
         :param str symbol: unified market symbol of the market trades were made in
         :param int [since]: the earliest time in ms to fetch trades for
         :param int [limit]: the maximum number of trade structures to retrieve
@@ -239,6 +242,7 @@ class hollaex(ccxt.async_support.hollaex):
     async def watch_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
         watches information on multiple orders made by the user
+        :see: https://apidocs.hollaex.com/#sending-receiving-messages
         :param str symbol: unified market symbol of the market orders were made in
         :param int [since]: the earliest time in ms to fetch orders for
         :param int [limit]: the maximum number of order structures to retrieve
@@ -350,6 +354,7 @@ class hollaex(ccxt.async_support.hollaex):
     async def watch_balance(self, params={}) -> Balances:
         """
         watch balance and get the amount of funds available for trading or funds locked in orders
+        :see: https://apidocs.hollaex.com/#sending-receiving-messages
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `balance structure <https://docs.ccxt.com/#/?id=balance-structure>`
         """

ccxt/pro/okx.py

@@ -2055,10 +2055,21 @@ class okx(ccxt.async_support.okx):
         try:
             if errorCode and errorCode != '0':
                 feedback = self.id + ' ' + self.json(message)
-                self.throw_exactly_matched_exception(self.exceptions['exact'], errorCode, feedback)
+                if errorCode != '1':
+                    self.throw_exactly_matched_exception(self.exceptions['exact'], errorCode, feedback)
                 messageString = self.safe_value(message, 'msg')
                 if messageString is not None:
                     self.throw_broadly_matched_exception(self.exceptions['broad'], messageString, feedback)
+                else:
+                    data = self.safe_list(message, 'data', [])
+                    for i in range(0, len(data)):
+                        d = data[i]
+                        errorCode = self.safe_string(d, 'sCode')
+                        if errorCode is not None:
+                            self.throw_exactly_matched_exception(self.exceptions['exact'], errorCode, feedback)
+                        messageString = self.safe_value(message, 'sMsg')
+                        if messageString is not None:
+                            self.throw_broadly_matched_exception(self.exceptions['broad'], messageString, feedback)
                 raise ExchangeError(feedback)
         except Exception as e:
             # if the message contains an id, it means it is a response to a request

ccxt/pro/p2b.py

@@ -5,7 +5,7 @@
 
 import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheByTimestamp
-from ccxt.base.types import Int, OrderBook, Ticker, Trade
+from ccxt.base.types import Int, OrderBook, Strings, Ticker, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import ExchangeError
@@ -34,7 +34,7 @@ class p2b(ccxt.async_support.p2b):
                 'watchOrders': False,
                 # 'watchStatus': True,
                 'watchTicker': True,
-                'watchTickers': False,  # in the docs but does not return anything when subscribed to
+                'watchTickers': True,
                 'watchTrades': True,
                 'watchTradesForSymbols': True,
             },
@@ -133,6 +133,36 @@ class p2b(ccxt.async_support.p2b):
         messageHash = name + '::' + market['symbol']
         return await self.subscribe(name + '.subscribe', messageHash, request, params)
 
+    async def watch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+        :see: https://github.com/P2B-team/P2B-WSS-Public/blob/main/wss_documentation.md#last-price
+        :see: https://github.com/P2B-team/P2B-WSS-Public/blob/main/wss_documentation.md#market-status
+        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 dict [params.method]: 'state'(default) or 'price'
+        :returns dict: a `ticker structure <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
+        await self.load_markets()
+        symbols = self.market_symbols(symbols, None, False)
+        watchTickerOptions = self.safe_dict(self.options, 'watchTicker')
+        name = self.safe_string(watchTickerOptions, 'name', 'state')  # or price
+        name, params = self.handle_option_and_params(params, 'method', 'name', name)
+        messageHashes = []
+        args = []
+        for i in range(0, len(symbols)):
+            market = self.market(symbols[i])
+            messageHashes.append(name + '::' + market['symbol'])
+            args.append(market['id'])
+        url = self.urls['api']['ws']
+        request: dict = {
+            'method': name + '.subscribe',
+            'params': args,
+            'id': self.milliseconds(),
+        }
+        await self.watch_multiple(url, messageHashes, self.extend(request, params), messageHashes)
+        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]:
         """
         get the list of most recent trades for a particular symbol
@@ -332,6 +362,7 @@ class p2b(ccxt.async_support.p2b):
         else:
             ticker = self.parse_ticker(tickerData, market)
         symbol = ticker['symbol']
+        self.tickers[symbol] = ticker
         messageHash = messageHashStart + '::' + symbol
         client.resolve(ticker, messageHash)
         return message

ccxt/pro/whitebit.py

@@ -5,7 +5,7 @@
 
 import ccxt.async_support
 from ccxt.async_support.base.ws.cache import ArrayCache, ArrayCacheBySymbolById, ArrayCacheByTimestamp
-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
@@ -26,6 +26,7 @@ class whitebit(ccxt.async_support.whitebit):
                 'watchOrderBook': True,
                 'watchOrders': True,
                 'watchTicker': True,
+                'watchTickers': True,
                 'watchTrades': True,
                 'watchTradesForSymbols': False,
             },
@@ -249,6 +250,33 @@ class whitebit(ccxt.async_support.whitebit):
         # every time we want to subscribe to another market we have to "re-subscribe" sending it all again
         return await self.watch_multiple_subscription(messageHash, method, symbol, False, params)
 
+    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://docs.whitebit.com/public/websocket/#market-statistics
+        :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)
+        method = 'market_subscribe'
+        url = self.urls['api']['ws']
+        id = self.nonce()
+        messageHashes = []
+        args = []
+        for i in range(0, len(symbols)):
+            market = self.market(symbols[i])
+            messageHashes.append('ticker:' + market['symbol'])
+            args.append(market['id'])
+        request: dict = {
+            'id': id,
+            'method': method,
+            'params': args,
+        }
+        await self.watch_multiple(url, messageHashes, self.extend(request, params), messageHashes)
+        return self.filter_by_array(self.tickers, 'symbol', symbols)
+
     def handle_ticker(self, client: Client, message):
         #
         #   {

ccxt/vertex.py

@@ -5,7 +5,7 @@
 
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.vertex import ImplicitAPI
-from ccxt.base.types import Balances, Currencies, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, TradingFees
+from ccxt.base.types import Balances, Currencies, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, FundingRate, FundingRates, Trade, TradingFees
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
@@ -1154,7 +1154,7 @@ class vertex(Exchange, ImplicitAPI):
         rows = self.safe_list(response, 'candlesticks', [])
         return self.parse_ohlcvs(rows, market, timeframe, since, limit)
 
-    def parse_funding_rate(self, ticker, market: Market = None):
+    def parse_funding_rate(self, ticker, market: Market = None) -> FundingRate:
         #
         # {
         #     "product_id": 4,
@@ -1208,9 +1208,10 @@ class vertex(Exchange, ImplicitAPI):
             'previousFundingRate': None,
             'previousFundingTimestamp': None,
             'previousFundingDatetime': None,
+            'interval': None,
         }
 
-    def fetch_funding_rate(self, symbol: str, params={}):
+    def fetch_funding_rate(self, symbol: str, params={}) -> FundingRate:
         """
         fetch the current funding rate
         :see: https://docs.vertexprotocol.com/developer-resources/api/archive-indexer/funding-rate
@@ -1235,13 +1236,13 @@ class vertex(Exchange, ImplicitAPI):
         #
         return self.parse_funding_rate(response, market)
 
-    def fetch_funding_rates(self, symbols: Strings = None, params={}):
+    def fetch_funding_rates(self, symbols: Strings = None, params={}) -> FundingRates:
         """
         fetches funding rates for multiple markets
         :see: https://docs.vertexprotocol.com/developer-resources/api/v2/contracts
         :param str[] symbols: unified symbols of the markets to fetch the funding rates for, all market funding rates are returned if not assigned
         :param dict [params]: extra parameters specific to the exchange API endpoint
-        :returns dict: an array of `funding rate structures <https://docs.ccxt.com/#/?id=funding-rate-structure>`
+        :returns dict[]: an array of `funding rate structures <https://docs.ccxt.com/#/?id=funding-rate-structure>`
         """
         self.load_markets()
         request = {}