ccxt 4.2.79__py2.py3-none-any.whl → 4.2.81__py2.py3-none-any.whl

ccxt/gate.py

@@ -6,7 +6,7 @@
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.gate import ImplicitAPI
 import hashlib
-from ccxt.base.types import Balances, Currency, FundingHistory, Greeks, Int, Leverage, Leverages, Market, MarketInterface, Num, Order, OrderBook, OrderRequest, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction, TransferEntry
+from ccxt.base.types import Balances, Currency, FundingHistory, Greeks, Int, Leverage, Leverages, Market, MarketInterface, Num, Option, OptionChain, Order, OrderBook, OrderRequest, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import PermissionDenied
@@ -150,6 +150,8 @@ class gate(Exchange, ImplicitAPI):
                 'fetchOpenInterest': False,
                 'fetchOpenInterestHistory': True,
                 'fetchOpenOrders': True,
+                'fetchOption': True,
+                'fetchOptionChain': True,
                 'fetchOrder': True,
                 'fetchOrderBook': True,
                 'fetchPosition': True,
@@ -3959,8 +3961,13 @@ class gate(Exchange, ImplicitAPI):
             'account': account,
         }
         if amount is not None:
-            amountKey = 'amount' if (market['spot']) else 'size'
-            request[amountKey] = self.amount_to_precision(symbol, amount)
+            if market['spot']:
+                request['amount'] = self.amount_to_precision(symbol, amount)
+            else:
+                if side == 'sell':
+                    request['size'] = Precise.string_neg(self.amount_to_precision(symbol, amount))
+                else:
+                    request['size'] = self.amount_to_precision(symbol, amount)
         if price is not None:
             request['price'] = self.price_to_precision(symbol, price)
         response = None
@@ -4690,8 +4697,8 @@ class gate(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = None if (symbol is None) else self.market(symbol)
-        stop = self.safe_value(params, 'stop')
-        params = self.omit(params, 'stop')
+        stop = self.safe_bool_2(params, 'stop', 'trigger')
+        params = self.omit(params, ['stop', 'trigger'])
         type, query = self.handle_market_type_and_params('cancelAllOrders', market, params)
         request, requestParams = self.multi_order_spot_prepare_request(market, stop, query) if (type == 'spot') else self.prepare_request(market, type, query)
         response = None
@@ -4985,7 +4992,7 @@ class gate(Exchange, ImplicitAPI):
             'unrealizedPnl': self.parse_number(unrealisedPnl),
             'realizedPnl': self.safe_number(position, 'realised_pnl'),
             'contracts': self.parse_number(Precise.string_abs(size)),
-            'contractSize': self.safe_value(market, 'contractSize'),
+            'contractSize': self.safe_number(market, 'contractSize'),
             # 'realisedPnl': position['realised_pnl'],
             'marginRatio': None,
             'liquidationPrice': self.safe_number(position, 'liq_price'),
@@ -6682,6 +6689,186 @@ class gate(Exchange, ImplicitAPI):
             'shortLeverage': leverageValue,
         }
 
+    def fetch_option(self, symbol: str, params={}) -> Option:
+        """
+        fetches option data that is commonly found in an option chain
+        :see: https://www.gate.io/docs/developers/apiv4/en/#query-specified-contract-detail
+        :param str symbol: unified market symbol
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: an `option chain structure <https://docs.ccxt.com/#/?id=option-chain-structure>`
+        """
+        self.load_markets()
+        market = self.market(symbol)
+        request = {
+            'contract': market['id'],
+        }
+        response = self.publicOptionsGetContractsContract(self.extend(request, params))
+        #
+        #     {
+        #         "is_active": True,
+        #         "mark_price_round": "0.01",
+        #         "settle_fee_rate": "0.00015",
+        #         "bid1_size": 30,
+        #         "taker_fee_rate": "0.0003",
+        #         "price_limit_fee_rate": "0.1",
+        #         "order_price_round": "0.1",
+        #         "tag": "month",
+        #         "ref_rebate_rate": "0",
+        #         "name": "ETH_USDT-20240628-4500-C",
+        #         "strike_price": "4500",
+        #         "ask1_price": "280.5",
+        #         "ref_discount_rate": "0",
+        #         "order_price_deviate": "0.2",
+        #         "ask1_size": -19,
+        #         "mark_price_down": "155.45",
+        #         "orderbook_id": 11724695,
+        #         "is_call": True,
+        #         "last_price": "188.7",
+        #         "mark_price": "274.26",
+        #         "underlying": "ETH_USDT",
+        #         "create_time": 1688024882,
+        #         "settle_limit_fee_rate": "0.1",
+        #         "orders_limit": 10,
+        #         "mark_price_up": "403.83",
+        #         "position_size": 80,
+        #         "order_size_max": 10000,
+        #         "position_limit": 100000,
+        #         "multiplier": "0.01",
+        #         "order_size_min": 1,
+        #         "trade_size": 229,
+        #         "underlying_price": "3326.6",
+        #         "maker_fee_rate": "0.0003",
+        #         "expiration_time": 1719561600,
+        #         "trade_id": 15,
+        #         "bid1_price": "269.3"
+        #     }
+        #
+        return self.parse_option(response, None, market)
+
+    def fetch_option_chain(self, code: str, params={}) -> OptionChain:
+        """
+        fetches data for an underlying asset that is commonly found in an option chain
+        :see: https://www.gate.io/docs/developers/apiv4/en/#list-all-the-contracts-with-specified-underlying-and-expiration-time
+        :param str currency: base currency to fetch an option chain for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :param str [params.underlying]: the underlying asset, can be obtained from fetchUnderlyingAssets()
+        :param int [params.expiration]: unix timestamp of the expiration time
+        :returns dict: a list of `option chain structures <https://docs.ccxt.com/#/?id=option-chain-structure>`
+        """
+        self.load_markets()
+        currency = self.currency(code)
+        request = {
+            'underlying': currency['code'] + '_USDT',
+        }
+        response = self.publicOptionsGetContracts(self.extend(request, params))
+        #
+        #     [
+        #         {
+        #             "is_active": True,
+        #             "mark_price_round": "0.1",
+        #             "settle_fee_rate": "0.00015",
+        #             "bid1_size": 434,
+        #             "taker_fee_rate": "0.0003",
+        #             "price_limit_fee_rate": "0.1",
+        #             "order_price_round": "1",
+        #             "tag": "day",
+        #             "ref_rebate_rate": "0",
+        #             "name": "BTC_USDT-20240324-63500-P",
+        #             "strike_price": "63500",
+        #             "ask1_price": "387",
+        #             "ref_discount_rate": "0",
+        #             "order_price_deviate": "0.15",
+        #             "ask1_size": -454,
+        #             "mark_price_down": "124.3",
+        #             "orderbook_id": 29600,
+        #             "is_call": False,
+        #             "last_price": "0",
+        #             "mark_price": "366.6",
+        #             "underlying": "BTC_USDT",
+        #             "create_time": 1711118829,
+        #             "settle_limit_fee_rate": "0.1",
+        #             "orders_limit": 10,
+        #             "mark_price_up": "630",
+        #             "position_size": 0,
+        #             "order_size_max": 10000,
+        #             "position_limit": 10000,
+        #             "multiplier": "0.01",
+        #             "order_size_min": 1,
+        #             "trade_size": 0,
+        #             "underlying_price": "64084.65",
+        #             "maker_fee_rate": "0.0003",
+        #             "expiration_time": 1711267200,
+        #             "trade_id": 0,
+        #             "bid1_price": "307"
+        #         },
+        #     ]
+        #
+        return self.parse_option_chain(response, None, 'name')
+
+    def parse_option(self, chain, currency: Currency = None, market: Market = None):
+        #
+        #     {
+        #         "is_active": True,
+        #         "mark_price_round": "0.1",
+        #         "settle_fee_rate": "0.00015",
+        #         "bid1_size": 434,
+        #         "taker_fee_rate": "0.0003",
+        #         "price_limit_fee_rate": "0.1",
+        #         "order_price_round": "1",
+        #         "tag": "day",
+        #         "ref_rebate_rate": "0",
+        #         "name": "BTC_USDT-20240324-63500-P",
+        #         "strike_price": "63500",
+        #         "ask1_price": "387",
+        #         "ref_discount_rate": "0",
+        #         "order_price_deviate": "0.15",
+        #         "ask1_size": -454,
+        #         "mark_price_down": "124.3",
+        #         "orderbook_id": 29600,
+        #         "is_call": False,
+        #         "last_price": "0",
+        #         "mark_price": "366.6",
+        #         "underlying": "BTC_USDT",
+        #         "create_time": 1711118829,
+        #         "settle_limit_fee_rate": "0.1",
+        #         "orders_limit": 10,
+        #         "mark_price_up": "630",
+        #         "position_size": 0,
+        #         "order_size_max": 10000,
+        #         "position_limit": 10000,
+        #         "multiplier": "0.01",
+        #         "order_size_min": 1,
+        #         "trade_size": 0,
+        #         "underlying_price": "64084.65",
+        #         "maker_fee_rate": "0.0003",
+        #         "expiration_time": 1711267200,
+        #         "trade_id": 0,
+        #         "bid1_price": "307"
+        #     }
+        #
+        marketId = self.safe_string(chain, 'name')
+        market = self.safe_market(marketId, market)
+        timestamp = self.safe_timestamp(chain, 'create_time')
+        return {
+            'info': chain,
+            'currency': None,
+            'symbol': market['symbol'],
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'impliedVolatility': None,
+            'openInterest': None,
+            'bidPrice': self.safe_number(chain, 'bid1_price'),
+            'askPrice': self.safe_number(chain, 'ask1_price'),
+            'midPrice': None,
+            'markPrice': self.safe_number(chain, 'mark_price'),
+            'lastPrice': self.safe_number(chain, 'last_price'),
+            'underlyingPrice': self.safe_number(chain, 'underlying_price'),
+            'change': None,
+            'percentage': None,
+            'baseVolume': None,
+            'quoteVolume': None,
+        }
+
     def handle_errors(self, code, reason, url, method, headers, body, response, requestHeaders, requestBody):
         if response is None:
             return None

ccxt/hyperliquid.py

@@ -754,6 +754,8 @@ class hyperliquid(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
+        vaultAddress = self.safe_string(params, 'vaultAddress')
+        params = self.omit(params, 'vaultAddress')
         symbol = market['symbol']
         order = {
             'symbol': symbol,
@@ -763,7 +765,10 @@ class hyperliquid(Exchange, ImplicitAPI):
             'price': price,
             'params': params,
         }
-        response = self.create_orders([order], params)
+        globalParams = {}
+        if vaultAddress is not None:
+            globalParams['vaultAddress'] = vaultAddress
+        response = self.create_orders([order], globalParams)
         first = self.safe_dict(response, 0)
         return first
 
@@ -807,7 +812,6 @@ class hyperliquid(Exchange, ImplicitAPI):
             amount = self.safe_string(rawOrder, 'amount')
             price = self.safe_string(rawOrder, 'price')
             orderParams = self.safe_dict(rawOrder, 'params', {})
-            orderParams = self.extend(params, orderParams)
             clientOrderId = self.safe_string_2(orderParams, 'clientOrderId', 'client_id')
             slippage = self.safe_string(orderParams, 'slippage', defaultSlippage)
             defaultTimeInForce = 'ioc' if (isMarket) else 'gtc'
@@ -847,6 +851,7 @@ class hyperliquid(Exchange, ImplicitAPI):
                 orderType['limit'] = {
                     'tif': timeInForce,
                 }
+            orderParams = self.omit(orderParams, ['clientOrderId', 'slippage', 'triggerPrice', 'stopPrice', 'stopLossPrice', 'takeProfitPrice', 'timeInForce', 'client_id'])
             orderObj = {
                 'a': self.parse_to_int(market['baseId']),
                 'b': isBuy,
@@ -858,8 +863,8 @@ class hyperliquid(Exchange, ImplicitAPI):
             }
             if clientOrderId is not None:
                 orderObj['c'] = clientOrderId
-            orderReq.append(orderObj)
-        vaultAddress = self.safe_string(params, 'vaultAddress')
+            orderReq.append(self.extend(orderObj, orderParams))
+        vaultAddress = self.format_vault_address(self.safe_string(params, 'vaultAddress'))
         orderAction = {
             'type': 'order',
             'orders': orderReq,
@@ -875,6 +880,9 @@ class hyperliquid(Exchange, ImplicitAPI):
             'signature': signature,
             # 'vaultAddress': vaultAddress,
         }
+        if vaultAddress is not None:
+            params = self.omit(params, 'vaultAddress')
+            request['vaultAddress'] = vaultAddress
         response = self.privatePostExchange(self.extend(request, params))
         #
         #     {
@@ -957,10 +965,13 @@ class hyperliquid(Exchange, ImplicitAPI):
                     'o': self.parse_to_numeric(ids[i]),
                 })
         cancelAction['cancels'] = cancelReq
-        vaultAddress = self.safe_string(params, 'vaultAddress')
+        vaultAddress = self.format_vault_address(self.safe_string(params, 'vaultAddress'))
         signature = self.sign_l1_action(cancelAction, nonce, vaultAddress)
         request['action'] = cancelAction
         request['signature'] = signature
+        if vaultAddress is not None:
+            params = self.omit(params, 'vaultAddress')
+            request['vaultAddress'] = vaultAddress
         response = self.privatePostExchange(self.extend(request, params))
         #
         #     {
@@ -1066,7 +1077,7 @@ class hyperliquid(Exchange, ImplicitAPI):
             'type': 'batchModify',
             'modifies': [modifyReq],
         }
-        vaultAddress = self.safe_string(params, 'vaultAddress')
+        vaultAddress = self.format_vault_address(self.safe_string(params, 'vaultAddress'))
         signature = self.sign_l1_action(modifyAction, nonce, vaultAddress)
         request = {
             'action': modifyAction,
@@ -1074,6 +1085,9 @@ class hyperliquid(Exchange, ImplicitAPI):
             'signature': signature,
             # 'vaultAddress': vaultAddress,
         }
+        if vaultAddress is not None:
+            params = self.omit(params, 'vaultAddress')
+            request['vaultAddress'] = vaultAddress
         response = self.privatePostExchange(self.extend(request, params))
         #
         #     {
@@ -1643,7 +1657,7 @@ class hyperliquid(Exchange, ImplicitAPI):
             'isolated': isIsolated,
             'hedged': None,
             'side': side,
-            'contracts': self.parse_number(quantity),
+            'contracts': self.safe_number(entry, 'szi'),
             'contractSize': None,
             'entryPrice': self.safe_number(entry, 'entryPx'),
             'markPrice': None,
@@ -1687,6 +1701,10 @@ class hyperliquid(Exchange, ImplicitAPI):
             'leverage': leverage,
         }
         vaultAddress = self.safe_string(params, 'vaultAddress')
+        if vaultAddress is not None:
+            params = self.omit(params, 'vaultAddress')
+            if vaultAddress.startswith('0x'):
+                vaultAddress = vaultAddress.replace('0x', '')
         signature = self.sign_l1_action(updateAction, nonce, vaultAddress)
         request = {
             'action': updateAction,
@@ -1694,6 +1712,8 @@ class hyperliquid(Exchange, ImplicitAPI):
             'signature': signature,
             # 'vaultAddress': vaultAddress,
         }
+        if vaultAddress is not None:
+            request['vaultAddress'] = vaultAddress
         response = self.privatePostExchange(self.extend(request, params))
         #
         #     {
@@ -1729,7 +1749,7 @@ class hyperliquid(Exchange, ImplicitAPI):
             'isCross': isCross,
             'leverage': leverage,
         }
-        vaultAddress = self.safe_string(params, 'vaultAddress')
+        vaultAddress = self.format_vault_address(self.safe_string(params, 'vaultAddress'))
         signature = self.sign_l1_action(updateAction, nonce, vaultAddress)
         request = {
             'action': updateAction,
@@ -1737,6 +1757,9 @@ class hyperliquid(Exchange, ImplicitAPI):
             'signature': signature,
             # 'vaultAddress': vaultAddress,
         }
+        if vaultAddress is not None:
+            params = self.omit(params, 'vaultAddress')
+            request['vaultAddress'] = vaultAddress
         response = self.privatePostExchange(self.extend(request, params))
         #
         #     {
@@ -1784,7 +1807,7 @@ class hyperliquid(Exchange, ImplicitAPI):
             'isBuy': True,
             'ntli': sz,
         }
-        vaultAddress = self.safe_string(params, 'vaultAddress')
+        vaultAddress = self.format_vault_address(self.safe_string(params, 'vaultAddress'))
         signature = self.sign_l1_action(updateAction, nonce, vaultAddress)
         request = {
             'action': updateAction,
@@ -1792,6 +1815,9 @@ class hyperliquid(Exchange, ImplicitAPI):
             'signature': signature,
             # 'vaultAddress': vaultAddress,
         }
+        if vaultAddress is not None:
+            params = self.omit(params, 'vaultAddress')
+            request['vaultAddress'] = vaultAddress
         response = self.privatePostExchange(self.extend(request, params))
         #
         #     {
@@ -1882,6 +1908,13 @@ class hyperliquid(Exchange, ImplicitAPI):
         response = self.privatePostExchange(self.extend(request, params))
         return response
 
+    def format_vault_address(self, address: Str = None):
+        if address is None:
+            return None
+        if address.startswith('0x'):
+            return address.replace('0x', '')
+        return address
+
     def handle_public_address(self, methodName: str, params: dict):
         userAux = None
         userAux, params = self.handle_option_and_params(params, methodName, 'user')

ccxt/mexc.py

@@ -899,8 +899,8 @@ class mexc(Exchange, ImplicitAPI):
                     '30032': InvalidOrder,  # Cannot exceed the maximum position
                     '30041': InvalidOrder,  # current order type can not place order
                     '60005': ExchangeError,  # your account is abnormal
-                    '700001': AuthenticationError,  # API-key format invalid
-                    '700002': AuthenticationError,  # Signature for self request is not valid
+                    '700001': AuthenticationError,  # {"code":700002,"msg":"Signature for self request is not valid."}  # same message for expired API keys
+                    '700002': AuthenticationError,  # Signature for self request is not valid  # or the API secret is incorrect
                     '700004': BadRequest,  # Param 'origClientOrderId' or 'orderId' must be sent, but both were empty/null
                     '700005': InvalidNonce,  # recvWindow must less than 60000
                     '700006': BadRequest,  # IP non white list

ccxt/okx.py

@@ -1833,16 +1833,27 @@ class okx(Exchange, ImplicitAPI):
         first = self.safe_value(data, 0, {})
         return self.parse_ticker(first, market)
 
-    def fetch_tickers_by_type(self, type, symbols: Strings = None, params={}):
+    def fetch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
+        """
+        fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
+        :see: https://www.okx.com/docs-v5/en/#order-book-trading-market-data-get-tickers
+        :param str[] [symbols]: unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a dictionary of `ticker structures <https://docs.ccxt.com/#/?id=ticker-structure>`
+        """
         self.load_markets()
+        symbols = self.market_symbols(symbols)
+        market = self.get_market_from_symbols(symbols)
+        marketType = None
+        marketType, params = self.handle_market_type_and_params('fetchTickers', market, params)
         request = {
-            'instType': self.convert_to_instrument_type(type),
+            'instType': self.convert_to_instrument_type(marketType),
         }
-        if type == 'option':
+        if marketType == 'option':
             defaultUnderlying = self.safe_value(self.options, 'defaultUnderlying', 'BTC-USD')
             currencyId = self.safe_string_2(params, 'uly', 'marketId', defaultUnderlying)
             if currencyId is None:
-                raise ArgumentsRequired(self.id + ' fetchTickersByType() requires an underlying uly or marketId parameter for options markets')
+                raise ArgumentsRequired(self.id + ' fetchTickers() requires an underlying uly or marketId parameter for options markets')
             else:
                 request['uly'] = currencyId
         response = self.publicGetMarketTickers(self.extend(request, params))
@@ -1872,26 +1883,9 @@ class okx(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        tickers = self.safe_value(response, 'data', [])
+        tickers = self.safe_list(response, 'data', [])
         return self.parse_tickers(tickers, symbols)
 
-    def fetch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
-        """
-        fetches price tickers for multiple markets, statistical information calculated over the past 24 hours for each market
-        :see: https://www.okx.com/docs-v5/en/#order-book-trading-market-data-get-tickers
-        :param str[]|None symbols: unified symbols of the markets to fetch the ticker for, all market tickers are returned if not assigned
-        :param dict [params]: extra parameters specific to the exchange API endpoint
-        :returns dict: a dictionary of `ticker structures <https://docs.ccxt.com/#/?id=ticker-structure>`
-        """
-        self.load_markets()
-        symbols = self.market_symbols(symbols)
-        first = self.safe_string(symbols, 0)
-        market = None
-        if first is not None:
-            market = self.market(first)
-        type, query = self.handle_market_type_and_params('fetchTickers', market, params)
-        return self.fetch_tickers_by_type(type, symbols, query)
-
     def parse_trade(self, trade, market: Market = None) -> Trade:
         #
         # public fetchTrades
@@ -4438,18 +4432,7 @@ class okx(Exchange, ImplicitAPI):
             if fee is None:
                 raise ArgumentsRequired(self.id + ' withdraw() requires a "fee" string parameter, network transaction fee must be ≥ 0. Withdrawals to OKCoin or OKX are fee-free, please set "0". Withdrawing to external digital asset address requires network transaction fee.')
         request['fee'] = self.number_to_string(fee)  # withdrawals to OKCoin or OKX are fee-free, please set 0
-        if 'password' in params:
-            request['pwd'] = params['password']
-        elif 'pwd' in params:
-            request['pwd'] = params['pwd']
-        else:
-            options = self.safe_value(self.options, 'withdraw', {})
-            password = self.safe_string_2(options, 'password', 'pwd')
-            if password is not None:
-                request['pwd'] = password
-        query = self.omit(params, ['fee', 'password', 'pwd'])
-        if not ('pwd' in request):
-            raise ExchangeError(self.id + ' withdraw() requires a password parameter or a pwd parameter, it must be the funding password, not the API passphrase')
+        query = self.omit(params, ['fee'])
         response = self.privatePostAssetWithdrawal(self.extend(request, query))
         #
         #     {

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.2.79'
+__version__ = '4.2.81'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/binance.py

@@ -89,7 +89,7 @@ class binance(ccxt.async_support.binance):
                     'future': 200,
                     'delivery': 200,
                 },
-                'streamBySubscriptionsHash': {},
+                'streamBySubscriptionsHash': self.create_safe_dictionary(),
                 'streamIndex': -1,
                 # get updates every 1000ms or 100ms
                 # or every 0ms in real-time for futures
@@ -97,7 +97,7 @@ class binance(ccxt.async_support.binance):
                 'tradesLimit': 1000,
                 'ordersLimit': 1000,
                 'OHLCVLimit': 1000,
-                'requestId': {},
+                'requestId': self.create_safe_dictionary(),
                 'watchOrderBookLimit': 1000,  # default limit
                 'watchTrades': {
                     'name': 'trade',  # 'trade' or 'aggTrade'
@@ -131,14 +131,14 @@ class binance(ccxt.async_support.binance):
         })
 
     def request_id(self, url):
-        options = self.safe_value(self.options, 'requestId', {})
+        options = self.safe_dict(self.options, 'requestId', self.create_safe_dictionary())
         previousValue = self.safe_integer(options, url, 0)
         newValue = self.sum(previousValue, 1)
         self.options['requestId'][url] = newValue
         return newValue
 
     def stream(self, type, subscriptionHash, numSubscriptions=1):
-        streamBySubscriptionsHash = self.safe_value(self.options, 'streamBySubscriptionsHash', {})
+        streamBySubscriptionsHash = self.safe_dict(self.options, 'streamBySubscriptionsHash', self.create_safe_dictionary())
         stream = self.safe_string(streamBySubscriptionsHash, subscriptionHash)
         if stream is None:
             streamIndex = self.safe_integer(self.options, 'streamIndex', -1)
@@ -151,7 +151,7 @@ class binance(ccxt.async_support.binance):
             self.options['streamBySubscriptionsHash'][subscriptionHash] = stream
             subscriptionsByStreams = self.safe_value(self.options, 'numSubscriptionsByStream')
             if subscriptionsByStreams is None:
-                self.options['numSubscriptionsByStream'] = {}
+                self.options['numSubscriptionsByStream'] = self.create_safe_dictionary()
             subscriptionsByStream = self.safe_integer(self.options['numSubscriptionsByStream'], stream, 0)
             newNumSubscriptions = subscriptionsByStream + numSubscriptions
             subscriptionLimitByStream = self.safe_integer(self.options['subscriptionLimitByStream'], type, 200)

ccxt/pro/bitopro.py

@@ -364,7 +364,8 @@ class bitopro(ccxt.async_support.bitopro):
                 },
             },
         }
-        self.options = self.extend(defaultOptions, self.options)
+        # self.options = self.extend(defaultOptions, self.options)
+        self.extend_exchange_options(defaultOptions)
         originalHeaders = self.options['ws']['options']['headers']
         headers = {
             'X-BITOPRO-API': 'ccxt',

ccxt/pro/gemini.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 Int, Order, OrderBook, Str, Tickers, Trade
+from ccxt.base.types import Int, Order, OrderBook, Str, Strings, Tickers, Trade
 from ccxt.async_support.base.ws.client import Client
 from typing import List
 from ccxt.base.errors import ExchangeError
@@ -393,7 +393,7 @@ class gemini(ccxt.async_support.gemini):
         orderbook = await self.helper_for_watch_multiple_construct('orderbook', symbols, params)
         return orderbook.limit()
 
-    async def watch_bids_asks(self, symbols: List[str], limit: Int = None, params={}) -> Tickers:
+    async def watch_bids_asks(self, symbols: Strings = None, params={}) -> Tickers:
         """
         watches best bid & ask for symbols
         :see: https://docs.gemini.com/websocket-api/#multi-market-data
@@ -851,7 +851,8 @@ class gemini(ccxt.async_support.gemini):
                 },
             },
         }
-        self.options = self.extend(defaultOptions, self.options)
+        # self.options = self.extend(defaultOptions, self.options)
+        self.extend_exchange_options(defaultOptions)
         originalHeaders = self.options['ws']['options']['headers']
         headers = {
             'X-GEMINI-APIKEY': self.apiKey,

ccxt/pro/phemex.py

@@ -27,6 +27,10 @@ class phemex(ccxt.async_support.phemex):
                 'watchOrderBook': True,
                 'watchOHLCV': True,
                 'watchPositions': None,  # TODO
+                # mutli-endpoints are not supported: https://github.com/ccxt/ccxt/pull/21490
+                'watchOrderBookForSymbols': False,
+                'watchTradesForSymbols': False,
+                'watchOHLCVForSymbols': False,
             },
             'urls': {
                 'test': {
@@ -536,9 +540,10 @@ class phemex(ccxt.async_support.phemex):
 
     async def watch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:
         """
+        :see: https://github.com/phemex/phemex-api-docs/blob/master/Public-Spot-API-en.md#subscribe-orderbook
         :see: https://github.com/phemex/phemex-api-docs/blob/master/Public-Hedged-Perpetual-API.md#subscribe-orderbook-for-new-model
         :see: https://github.com/phemex/phemex-api-docs/blob/master/Public-Contract-API-en.md#subscribe-30-levels-orderbook
-        :see: https://github.com/phemex/phemex-api-docs/blob/master/Public-Spot-API-en.md#subscribe-orderbook
+        :see: https://github.com/phemex/phemex-api-docs/blob/master/Public-Contract-API-en.md#subscribe-full-orderbook
         watches information on open orders with bid(buy) and ask(sell) prices, volumes and other data
         :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

ccxt/test/base/test_ohlcv.py

@@ -21,8 +21,9 @@ def test_ohlcv(exchange, skipped_properties, method, entry, symbol, now):
     test_shared_methods.assert_timestamp_and_datetime(exchange, skipped_properties, method, entry, now, 0)
     log_text = test_shared_methods.log_template(exchange, method, entry)
     #
-    length = len(entry)
-    assert length >= 6, 'ohlcv array length should be >= 6;' + log_text
+    assert len(entry) >= 6, 'ohlcv array length should be >= 6;' + log_text
+    if not ('roundTimestamp' in skipped_properties):
+        test_shared_methods.assert_round_minute_timestamp(exchange, skipped_properties, method, entry, 0)
     high = exchange.safe_string(entry, 2)
     low = exchange.safe_string(entry, 3)
     test_shared_methods.assert_less_or_equal(exchange, skipped_properties, method, entry, '1', high)

ccxt/test/base/test_shared_methods.py

@@ -343,3 +343,11 @@ def assert_non_emtpy_array(exchange, skipped_properties, method, entry, hint=Non
     if not ('emptyResponse' in skipped_properties):
         return
     assert len(entry) > 0, 'response is expected to be a non-empty array' + log_text + ' (add \"emptyResponse\" in skip-tests.json to skip this check)'
+
+
+def assert_round_minute_timestamp(exchange, skipped_properties, method, entry, key):
+    if key in skipped_properties:
+        return
+    log_text = log_template(exchange, method, entry)
+    ts = exchange.safe_string(entry, key)
+    assert Precise.string_mod(ts, '60000') == '0', 'timestamp should be a multiple of 60 seconds (1 minute)' + log_text