ccxt 4.2.78__py2.py3-none-any.whl → 4.2.80__py2.py3-none-any.whl

ccxt/deribit.py

@@ -6,7 +6,7 @@
 from ccxt.base.exchange import Exchange
 from ccxt.abstract.deribit import ImplicitAPI
 import hashlib
-from ccxt.base.types import Account, Balances, Currency, Greeks, Int, Market, MarketInterface, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction, TransferEntry
+from ccxt.base.types import Account, Balances, Currency, Greeks, Int, Market, MarketInterface, Num, Option, OptionChain, Order, OrderBook, 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
@@ -83,6 +83,8 @@ class deribit(Exchange, ImplicitAPI):
                 'fetchMyTrades': True,
                 'fetchOHLCV': True,
                 'fetchOpenOrders': True,
+                'fetchOption': True,
+                'fetchOptionChain': True,
                 'fetchOrder': True,
                 'fetchOrderBook': True,
                 'fetchOrders': False,
@@ -3270,6 +3272,155 @@ class deribit(Exchange, ImplicitAPI):
             'info': greeks,
         }
 
+    def fetch_option(self, symbol: str, params={}) -> Option:
+        """
+        fetches option data that is commonly found in an option chain
+        :see: https://docs.deribit.com/#public-get_book_summary_by_instrument
+        :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 = {
+            'instrument_name': market['id'],
+        }
+        response = self.publicGetGetBookSummaryByInstrument(self.extend(request, params))
+        #
+        #     {
+        #         "jsonrpc": "2.0",
+        #         "result": [
+        #             {
+        #                 "mid_price": 0.04025,
+        #                 "volume_usd": 11045.12,
+        #                 "quote_currency": "BTC",
+        #                 "estimated_delivery_price": 65444.72,
+        #                 "creation_timestamp": 1711100949273,
+        #                 "base_currency": "BTC",
+        #                 "underlying_index": "BTC-27DEC24",
+        #                 "underlying_price": 73742.14,
+        #                 "volume": 4.0,
+        #                 "interest_rate": 0.0,
+        #                 "price_change": -6.9767,
+        #                 "open_interest": 274.2,
+        #                 "ask_price": 0.042,
+        #                 "bid_price": 0.0385,
+        #                 "instrument_name": "BTC-27DEC24-240000-C",
+        #                 "mark_price": 0.04007735,
+        #                 "last": 0.04,
+        #                 "low": 0.04,
+        #                 "high": 0.043
+        #             }
+        #         ],
+        #         "usIn": 1711100949273223,
+        #         "usOut": 1711100949273580,
+        #         "usDiff": 357,
+        #         "testnet": False
+        #     }
+        #
+        result = self.safe_list(response, 'result', [])
+        chain = self.safe_dict(result, 0, {})
+        return self.parse_option(chain, 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://docs.deribit.com/#public-get_book_summary_by_currency
+        :param str currency: base currency to fetch an option chain for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a list of `option chain structures <https://docs.ccxt.com/#/?id=option-chain-structure>`
+        """
+        self.load_markets()
+        currency = self.currency(code)
+        request = {
+            'currency': currency['id'],
+            'kind': 'option',
+        }
+        response = self.publicGetGetBookSummaryByCurrency(self.extend(request, params))
+        #
+        #     {
+        #         "jsonrpc": "2.0",
+        #         "result": [
+        #             {
+        #                 "mid_price": 0.4075,
+        #                 "volume_usd": 2836.83,
+        #                 "quote_currency": "BTC",
+        #                 "estimated_delivery_price": 65479.26,
+        #                 "creation_timestamp": 1711101594477,
+        #                 "base_currency": "BTC",
+        #                 "underlying_index": "BTC-28JUN24",
+        #                 "underlying_price": 68827.27,
+        #                 "volume": 0.1,
+        #                 "interest_rate": 0.0,
+        #                 "price_change": 0.0,
+        #                 "open_interest": 364.1,
+        #                 "ask_price": 0.411,
+        #                 "bid_price": 0.404,
+        #                 "instrument_name": "BTC-28JUN24-42000-C",
+        #                 "mark_price": 0.40752052,
+        #                 "last": 0.423,
+        #                 "low": 0.423,
+        #                 "high": 0.423
+        #             }
+        #         ],
+        #         "usIn": 1711101594456388,
+        #         "usOut": 1711101594484065,
+        #         "usDiff": 27677,
+        #         "testnet": False
+        #     }
+        #
+        result = self.safe_list(response, 'result', [])
+        return self.parse_option_chain(result, 'base_currency', 'instrument_name')
+
+    def parse_option(self, chain, currency: Currency = None, market: Market = None):
+        #
+        #     {
+        #         "mid_price": 0.04025,
+        #         "volume_usd": 11045.12,
+        #         "quote_currency": "BTC",
+        #         "estimated_delivery_price": 65444.72,
+        #         "creation_timestamp": 1711100949273,
+        #         "base_currency": "BTC",
+        #         "underlying_index": "BTC-27DEC24",
+        #         "underlying_price": 73742.14,
+        #         "volume": 4.0,
+        #         "interest_rate": 0.0,
+        #         "price_change": -6.9767,
+        #         "open_interest": 274.2,
+        #         "ask_price": 0.042,
+        #         "bid_price": 0.0385,
+        #         "instrument_name": "BTC-27DEC24-240000-C",
+        #         "mark_price": 0.04007735,
+        #         "last": 0.04,
+        #         "low": 0.04,
+        #         "high": 0.043
+        #     }
+        #
+        marketId = self.safe_string(chain, 'instrument_name')
+        market = self.safe_market(marketId, market)
+        currencyId = self.safe_string(chain, 'base_currency')
+        code = self.safe_currency_code(currencyId, currency)
+        timestamp = self.safe_integer(chain, 'timestamp')
+        return {
+            'info': chain,
+            'currency': code['code'],
+            'symbol': market['symbol'],
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'impliedVolatility': None,
+            'openInterest': self.safe_number(chain, 'open_interest'),
+            'bidPrice': self.safe_number(chain, 'bid_price'),
+            'askPrice': self.safe_number(chain, 'ask_price'),
+            'midPrice': self.safe_number(chain, 'mid_price'),
+            'markPrice': self.safe_number(chain, 'mark_price'),
+            'lastPrice': self.safe_number(chain, 'last'),
+            'underlyingPrice': self.safe_number(chain, 'underlying_price'),
+            'change': None,
+            'percentage': self.safe_number(chain, 'price_change'),
+            'baseVolume': self.safe_number(chain, 'volume'),
+            'quoteVolume': self.safe_number(chain, 'volume_usd'),
+        }
+
     def nonce(self):
         return self.milliseconds()
 

ccxt/gate.py

@@ -328,6 +328,7 @@ class gate(Exchange, ImplicitAPI):
                             'loan_records': 20 / 15,
                             'interest_records': 20 / 15,
                             'estimate_rate': 20 / 15,
+                            'currency_discount_tiers': 20 / 15,
                         },
                         'post': {
                             'account_mode': 20 / 15,
@@ -3958,7 +3959,13 @@ class gate(Exchange, ImplicitAPI):
             'account': account,
         }
         if amount is not None:
-            request['amount'] = 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
@@ -4688,8 +4695,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
@@ -4983,7 +4990,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'),

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/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.2.78'
+__version__ = '4.2.80'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/alpaca.py

@@ -562,7 +562,7 @@ class alpaca(ccxt.async_support.alpaca):
                     },
                 }
             self.watch(url, messageHash, request, messageHash, future)
-        return future
+        return await future
 
     def handle_error_message(self, client: Client, message):
         #

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/bitfinex2.py

@@ -812,7 +812,7 @@ class bitfinex2(ccxt.async_support.bitfinex2):
             }
             message = self.extend(request, params)
             self.watch(url, messageHash, message, messageHash)
-        return future
+        return await future
 
     def handle_authentication_message(self, client: Client, message):
         messageHash = 'authenticated'

ccxt/pro/bitget.py

@@ -1523,7 +1523,7 @@ class bitget(ccxt.async_support.bitget):
             }
             message = self.extend(request, params)
             self.watch(url, messageHash, message, messageHash)
-        return future
+        return await future
 
     async def watch_private(self, messageHash, subscriptionHash, args, params={}):
         await self.authenticate()

ccxt/pro/bitmart.py

@@ -1312,7 +1312,7 @@ class bitmart(ccxt.async_support.bitmart):
                 }
             message = self.extend(request, params)
             self.watch(url, messageHash, message, messageHash)
-        return future
+        return await future
 
     def handle_subscription_status(self, client: Client, message):
         #

ccxt/pro/bitmex.py

@@ -599,7 +599,7 @@ class bitmex(ccxt.async_support.bitmex):
             }
             message = self.extend(request, params)
             self.watch(url, messageHash, message, messageHash)
-        return future
+        return await future
 
     def handle_authentication_message(self, client: Client, message):
         authenticated = self.safe_bool(message, 'success', False)

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/blockchaincom.py

@@ -735,4 +735,4 @@ class blockchaincom(ccxt.async_support.blockchaincom):
                 'token': self.secret,
             }
             return self.watch(url, messageHash, self.extend(request, params), messageHash)
-        return future
+        return await future

ccxt/pro/bybit.py

@@ -974,8 +974,21 @@ class bybit(ccxt.async_support.bybit):
         for i in range(0, len(rawPositions)):
             rawPosition = rawPositions[i]
             position = self.parse_position(rawPosition)
+            side = self.safe_string(position, 'side')
+            # hacky solution to handle closing positions
+            # without crashing, we should handle self properly later
             newPositions.append(position)
-            cache.append(position)
+            if side is None or side == '':
+                # closing update, adding both sides to "reset" both sides
+                # since we don't know which side is being closed
+                position['side'] = 'long'
+                cache.append(position)
+                position['side'] = 'short'
+                cache.append(position)
+                position['side'] = None
+            else:
+                # regular update
+                cache.append(position)
         messageHashes = self.find_message_hashes(client, 'positions::')
         for i in range(0, len(messageHashes)):
             messageHash = messageHashes[i]

ccxt/pro/cex.py

@@ -157,16 +157,20 @@ class cex(ccxt.async_support.cex):
         #     {
         #         "e": "history",
         #         "data": [
-        #             "sell:1665467367741:3888551:19058.8:14541219",
-        #             "buy:1665467367741:1059339:19071.5:14541218",
+        #            'buy:1710255706095:444444:71222.2:14892622'
+        #            'sell:1710255658251:42530:71300:14892621'
+        #            'buy:1710252424241:87913:72800:14892620'
+        #            ... timestamp descending
         #         ]
         #     }
         #
-        data = self.safe_value(message, 'data', [])
+        data = self.safe_list(message, 'data', [])
         limit = self.safe_integer(self.options, 'tradesLimit', 1000)
         stored = ArrayCache(limit)
-        for i in range(0, len(data)):
-            rawTrade = data[i]
+        dataLength = len(data)
+        for i in range(0, dataLength):
+            index = dataLength - 1 - i
+            rawTrade = data[index]
             parsed = self.parse_ws_old_trade(rawTrade)
             stored.append(parsed)
         messageHash = 'trades'

ccxt/pro/cryptocom.py

@@ -931,7 +931,7 @@ class cryptocom(ccxt.async_support.cryptocom):
             }
             message = self.extend(request, params)
             self.watch(url, messageHash, message, messageHash)
-        return future
+        return await future
 
     def handle_ping(self, client: Client, message):
         self.spawn(self.pong, client, message)

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/hitbtc.py

@@ -119,7 +119,7 @@ class hitbtc(ccxt.async_support.hitbtc):
             #        }
             #    }
             #
-        return future
+        return await future
 
     async def subscribe_public(self, name: str, messageHashPrefix: str, symbols: Strings = None, params={}):
         """

ccxt/pro/htx.py

@@ -2205,4 +2205,4 @@ class htx(ccxt.async_support.htx):
                 'params': params,
             }
             self.watch(url, messageHash, request, messageHash, subscription)
-        return future
+        return await future

ccxt/pro/okcoin.py

@@ -452,7 +452,7 @@ class okcoin(ccxt.async_support.okcoin):
                 ],
             }
             self.spawn(self.watch, url, messageHash, request, messageHash, future)
-        return future
+        return await future
 
     async def watch_balance(self, params={}) -> Balances:
         """

ccxt/pro/onetrading.py

@@ -1272,4 +1272,4 @@ class onetrading(ccxt.async_support.onetrading):
                 'api_token': self.apiKey,
             }
             self.watch(url, messageHash, self.extend(request, params), messageHash)
-        return future
+        return await future