ccxt 4.3.29__py2.py3-none-any.whl → 4.3.31__py2.py3-none-any.whl

ccxt/pro/coinex.py

@@ -238,7 +238,7 @@ class coinex(ccxt.async_support.coinex):
         type, params = self.handle_market_type_and_params('watchBalance', None, params)
         url = self.urls['api']['ws'][type]
         currencies = list(self.currencies_by_id.keys())
-        subscribe = {
+        subscribe: dict = {
             'method': 'asset.subscribe',
             'params': currencies,
             'id': self.request_id(),
@@ -425,7 +425,7 @@ class coinex(ccxt.async_support.coinex):
         messageHash = 'tickers'
         if symbols is not None:
             messageHash = 'tickers::' + ','.join(symbols)
-        subscribe = {
+        subscribe: dict = {
             'method': 'state.subscribe',
             'id': self.request_id(),
             'params': [],
@@ -456,7 +456,7 @@ class coinex(ccxt.async_support.coinex):
         subscriptionHash = 'trades'
         subscribedSymbols = self.safe_value(self.options, 'watchTradesSubscriptions', [])
         subscribedSymbols.append(market['id'])
-        message = {
+        message: dict = {
             'method': 'deals.subscribe',
             'params': subscribedSymbols,
             'id': self.request_id(),
@@ -498,7 +498,7 @@ class coinex(ccxt.async_support.coinex):
         params = self.omit(params, 'aggregation')
         watchOrderBookSubscriptions = self.safe_value(self.options, 'watchOrderBookSubscriptions', {})
         watchOrderBookSubscriptions[symbol] = [market['id'], limit, aggregation, True]
-        subscribe = {
+        subscribe: dict = {
             'method': 'depth.subscribe_multi',
             'id': self.request_id(),
             'params': list(watchOrderBookSubscriptions.values()),
@@ -539,7 +539,7 @@ class coinex(ccxt.async_support.coinex):
         if watchOHLCVWarning and existingSubscription is not None and (subSymbol != symbol or subTimeframe != timeframe):
             raise ExchangeError(self.id + ' watchOHLCV() can only watch one symbol and timeframe at a time. To supress self warning set watchOHLCVWarning to False in options')
         timeframes = self.safe_value(self.options, 'timeframes', {})
-        subscribe = {
+        subscribe: dict = {
             'method': 'kline.subscribe',
             'id': self.request_id(),
             'params': [
@@ -547,7 +547,7 @@ class coinex(ccxt.async_support.coinex):
                 self.safe_integer(timeframes, timeframe),
             ],
         }
-        subscription = {
+        subscription: dict = {
             'symbol': symbol,
             'timeframe': timeframe,
         }
@@ -580,7 +580,7 @@ class coinex(ccxt.async_support.coinex):
         if since is None:
             since = 1640995200  # January 1, 2022
         id = self.request_id()
-        subscribe = {
+        subscribe: dict = {
             'method': 'kline.query',
             'params': [
                 market['id'],
@@ -590,7 +590,7 @@ class coinex(ccxt.async_support.coinex):
             ],
             'id': id,
         }
-        subscription = {
+        subscription: dict = {
             'id': id,
             'future': messageHash,
         }
@@ -668,7 +668,7 @@ class coinex(ccxt.async_support.coinex):
         messageHash = 'orders'
         market = None
         type, query = self.handle_market_type_and_params('watchOrders', market, params)
-        message = {
+        message: dict = {
             'method': 'order.subscribe',
             'id': self.request_id(),
         }
@@ -943,7 +943,7 @@ class coinex(ccxt.async_support.coinex):
         }, market)
 
     def parse_ws_order_status(self, status):
-        statuses = {
+        statuses: dict = {
             '0': 'pending',
             '1': 'ok',
         }
@@ -954,7 +954,7 @@ class coinex(ccxt.async_support.coinex):
         if error is not None:
             raise ExchangeError(self.id + ' ' + self.json(error))
         method = self.safe_string(message, 'method')
-        handlers = {
+        handlers: dict = {
             'state.update': self.handle_ticker,
             'asset.update': self.handle_balance,
             'deals.update': self.handle_trades,
@@ -1018,13 +1018,13 @@ class coinex(ccxt.async_support.coinex):
             if authenticated is not None:
                 return await future
             requestId = self.request_id()
-            subscribe = {
+            subscribe: dict = {
                 'id': requestId,
                 'future': spotMessageHash,
             }
             signData = 'access_id=' + self.apiKey + '&tonce=' + self.number_to_string(time) + '&secret_key=' + self.secret
             hash = self.hash(self.encode(signData), 'md5')
-            request = {
+            request: dict = {
                 'method': 'server.sign',
                 'params': [
                     self.apiKey,
@@ -1040,13 +1040,13 @@ class coinex(ccxt.async_support.coinex):
             if authenticated is not None:
                 return await future
             requestId = self.request_id()
-            subscribe = {
+            subscribe: dict = {
                 'id': requestId,
                 'future': swapMessageHash,
             }
             signData = 'access_id=' + self.apiKey + '&timestamp=' + self.number_to_string(time) + '&secret_key=' + self.secret
             hash = self.hash(self.encode(signData), 'sha256', 'hex')
-            request = {
+            request: dict = {
                 'method': 'server.sign',
                 'params': [
                     self.apiKey,

ccxt/pro/coinone.py

@@ -64,7 +64,7 @@ class coinone(ccxt.async_support.coinone):
         market = self.market(symbol)
         messageHash = 'orderbook:' + market['symbol']
         url = self.urls['api']['ws']
-        request = {
+        request: dict = {
             'request_type': 'SUBSCRIBE',
             'channel': 'ORDERBOOK',
             'topic': {
@@ -140,7 +140,7 @@ class coinone(ccxt.async_support.coinone):
         market = self.market(symbol)
         messageHash = 'ticker:' + market['symbol']
         url = self.urls['api']['ws']
-        request = {
+        request: dict = {
             'request_type': 'SUBSCRIBE',
             'channel': 'TICKER',
             'topic': {
@@ -258,7 +258,7 @@ class coinone(ccxt.async_support.coinone):
         market = self.market(symbol)
         messageHash = 'trade:' + market['symbol']
         url = self.urls['api']['ws']
-        request = {
+        request: dict = {
             'request_type': 'SUBSCRIBE',
             'channel': 'TRADE',
             'topic': {
@@ -363,7 +363,7 @@ class coinone(ccxt.async_support.coinone):
             return
         if type == 'DATA':
             topic = self.safe_string(message, 'channel', '')
-            methods = {
+            methods: dict = {
                 'ORDERBOOK': self.handle_order_book,
                 'TICKER': self.handle_ticker,
                 'TRADE': self.handle_trades,

ccxt/pro/cryptocom.py

@@ -504,7 +504,7 @@ class cryptocom(ccxt.async_support.cryptocom):
         await self.authenticate()
         url = self.urls['api']['ws']['private']
         id = self.nonce()
-        request = {
+        request: dict = {
             'method': 'subscribe',
             'params': {
                 'channels': ['user.position_balance'],
@@ -688,7 +688,7 @@ class cryptocom(ccxt.async_support.cryptocom):
         """
         await self.load_markets()
         params = self.create_order_request(symbol, type, side, amount, price, params)
-        request = {
+        request: dict = {
             'method': 'private/create-order',
             'params': params,
         }
@@ -725,7 +725,7 @@ class cryptocom(ccxt.async_support.cryptocom):
         params = self.extend({
             'order_id': id,
         }, params)
-        request = {
+        request: dict = {
             'method': 'private/cancel-order',
             'params': params,
         }
@@ -742,7 +742,7 @@ class cryptocom(ccxt.async_support.cryptocom):
         """
         await self.load_markets()
         market = None
-        request = {
+        request: dict = {
             'method': 'private/cancel-all-orders',
             'params': self.extend({}, params),
         }
@@ -766,7 +766,7 @@ class cryptocom(ccxt.async_support.cryptocom):
     async def watch_public(self, messageHash, params={}):
         url = self.urls['api']['ws']['public']
         id = self.nonce()
-        request = {
+        request: dict = {
             'method': 'subscribe',
             'params': {
                 'channels': [messageHash],
@@ -779,7 +779,7 @@ class cryptocom(ccxt.async_support.cryptocom):
     async def watch_public_multiple(self, messageHashes, topics, params={}):
         url = self.urls['api']['ws']['public']
         id = self.nonce()
-        request = {
+        request: dict = {
             'method': 'subscribe',
             'params': {
                 'channels': topics,
@@ -792,7 +792,7 @@ class cryptocom(ccxt.async_support.cryptocom):
     async def watch_private_request(self, nonce, params={}):
         await self.authenticate()
         url = self.urls['api']['ws']['private']
-        request = {
+        request: dict = {
             'id': nonce,
             'nonce': nonce,
         }
@@ -803,7 +803,7 @@ class cryptocom(ccxt.async_support.cryptocom):
         await self.authenticate()
         url = self.urls['api']['ws']['private']
         id = self.nonce()
-        request = {
+        request: dict = {
             'method': 'subscribe',
             'params': {
                 'channels': [messageHash],
@@ -842,7 +842,7 @@ class cryptocom(ccxt.async_support.cryptocom):
             return True
 
     def handle_subscribe(self, client: Client, message):
-        methods = {
+        methods: dict = {
             'candlestick': self.handle_ohlcv,
             'ticker': self.handle_ticker,
             'trade': self.handle_trades,
@@ -899,7 +899,7 @@ class cryptocom(ccxt.async_support.cryptocom):
         if self.handle_error_message(client, message):
             return
         method = self.safe_string(message, 'method')
-        methods = {
+        methods: dict = {
             '': self.handle_ping,
             'public/heartbeat': self.handle_ping,
             'public/auth': self.handle_authenticate,
@@ -925,7 +925,7 @@ class cryptocom(ccxt.async_support.cryptocom):
             nonce = str(self.nonce())
             auth = method + nonce + self.apiKey + nonce
             signature = self.hmac(self.encode(auth), self.encode(self.secret), hashlib.sha256)
-            request = {
+            request: dict = {
                 'id': nonce,
                 'nonce': nonce,
                 'method': method,

ccxt/pro/currencycom.py

@@ -306,7 +306,7 @@ class currencycom(ccxt.async_support.currencycom):
         messageHash = '/api/v1/account'
         url = self.urls['api']['ws']
         requestId = str(self.request_id())
-        payload = {
+        payload: dict = {
             'timestamp': self.milliseconds(),
             'apiKey': self.apiKey,
         }
@@ -402,7 +402,7 @@ class currencycom(ccxt.async_support.currencycom):
         destination = 'OHLCMarketData.subscribe'
         messageHash = destination + ':' + timeframe
         timeframes = self.safe_value(self.options, 'timeframes')
-        request = {
+        request: dict = {
             'destination': destination,
             'payload': {
                 'intervals': [
@@ -512,7 +512,7 @@ class currencycom(ccxt.async_support.currencycom):
                 if status == 'OK':
                     subscriptionDestination = self.safe_string(subscription, 'destination')
                     if subscriptionDestination is not None:
-                        methods = {
+                        methods: dict = {
                             '/api/v1/ticker/24hr': self.handle_ticker,
                             '/api/v1/account': self.handle_balance,
                         }
@@ -524,7 +524,7 @@ class currencycom(ccxt.async_support.currencycom):
                             return
         destination = self.safe_string(message, 'destination')
         if destination is not None:
-            methods = {
+            methods: dict = {
                 'marketdepth.event': self.handle_order_book,
                 'internal.trade': self.handle_trades,
                 'ohlc.event': self.handle_ohlcv,

ccxt/pro/deribit.py

@@ -95,7 +95,7 @@ class deribit(ccxt.async_support.deribit):
         for i in range(0, len(currencies)):
             currencyCode = currencies[i]
             channels.append('user.portfolio.' + currencyCode)
-        subscribe = {
+        subscribe: dict = {
             'jsonrpc': '2.0',
             'method': 'private/subscribe',
             'params': {
@@ -178,7 +178,7 @@ class deribit(ccxt.async_support.deribit):
         if interval == 'raw':
             await self.authenticate()
         channel = 'ticker.' + market['id'] + '.' + interval
-        message = {
+        message: dict = {
             'jsonrpc': '2.0',
             'method': 'public/subscribe',
             'params': {
@@ -324,7 +324,7 @@ class deribit(ccxt.async_support.deribit):
         interval = self.safe_string(params, 'interval', 'raw')
         params = self.omit(params, 'interval')
         channel = 'user.trades.any.any.' + interval
-        message = {
+        message: dict = {
             'jsonrpc': '2.0',
             'method': 'private/subscribe',
             'params': {
@@ -377,7 +377,7 @@ class deribit(ccxt.async_support.deribit):
             limit = self.safe_integer(self.options, 'tradesLimit', 1000)
             cachedTrades = ArrayCacheBySymbolById(limit)
         parsed = self.parse_trades(trades)
-        marketIds = {}
+        marketIds: dict = {}
         for i in range(0, len(parsed)):
             trade = parsed[i]
             cachedTrades.append(trade)
@@ -549,7 +549,7 @@ class deribit(ccxt.async_support.deribit):
         kind = self.safe_string(params, 'kind', 'any')
         params = self.omit(params, 'interval', 'currency', 'kind')
         channel = 'user.orders.' + kind + '.' + currency + '.' + interval
-        message = {
+        message: dict = {
             'jsonrpc': '2.0',
             'method': 'private/subscribe',
             'params': {
@@ -735,7 +735,7 @@ class deribit(ccxt.async_support.deribit):
             message = channelName + '.' + market['id'] + '.' + channelDescriptor
             rawSubscriptions.append(message)
             messageHashes.append(channelName + '|' + market['symbol'] + '|' + channelDescriptor)
-        request = {
+        request: dict = {
             'jsonrpc': '2.0',
             'method': 'public/subscribe',
             'params': {
@@ -818,12 +818,12 @@ class deribit(ccxt.async_support.deribit):
         if channel is not None:
             parts = channel.split('.')
             channelId = self.safe_string(parts, 0)
-            userHandlers = {
+            userHandlers: dict = {
                 'trades': self.handle_my_trades,
                 'portfolio': self.handle_balance,
                 'orders': self.handle_orders,
             }
-            handlers = {
+            handlers: dict = {
                 'ticker': self.handle_ticker,
                 'book': self.handle_order_book,
                 'trades': self.handle_trades,
@@ -874,7 +874,7 @@ class deribit(ccxt.async_support.deribit):
             self.check_required_credentials()
             requestId = self.request_id()
             signature = self.hmac(self.encode(timeString + '\n' + nonce + '\n'), self.encode(self.secret), hashlib.sha256)
-            request = {
+            request: dict = {
                 'jsonrpc': '2.0',
                 'id': requestId,
                 'method': 'public/auth',

ccxt/pro/exmo.py

@@ -59,7 +59,7 @@ class exmo(ccxt.async_support.exmo):
         type, query = self.handle_market_type_and_params('watchBalance', None, params)
         messageHash = 'balance:' + type
         url = self.urls['api']['ws'][type]
-        subscribe = {
+        subscribe: dict = {
             'method': 'subscribe',
             'topics': [type + '/wallet'],
             'id': self.request_id(),
@@ -208,7 +208,7 @@ class exmo(ccxt.async_support.exmo):
         symbol = market['symbol']
         url = self.urls['api']['ws']['public']
         messageHash = 'ticker:' + symbol
-        message = {
+        message: dict = {
             'method': 'subscribe',
             'topics': [
                 'spot/ticker:' + market['id'],
@@ -263,7 +263,7 @@ class exmo(ccxt.async_support.exmo):
         symbol = market['symbol']
         url = self.urls['api']['ws']['public']
         messageHash = 'trades:' + symbol
-        message = {
+        message: dict = {
             'method': 'subscribe',
             'topics': [
                 'spot/trades:' + market['id'],
@@ -329,7 +329,7 @@ class exmo(ccxt.async_support.exmo):
             market = self.market(symbol)
             symbol = market['symbol']
             messageHash = 'myTrades:' + market['symbol']
-        message = {
+        message: dict = {
             'method': 'subscribe',
             'topics': [
                 type + '/user_trades',
@@ -417,7 +417,7 @@ class exmo(ccxt.async_support.exmo):
             rawTrade = self.safe_value(message, 'data', {})
             rawTrades = [rawTrade]
         trades = self.parse_trades(rawTrades)
-        symbols = {}
+        symbols: dict = {}
         for j in range(0, len(trades)):
             trade = trades[j]
             myTrades.append(trade)
@@ -443,7 +443,7 @@ class exmo(ccxt.async_support.exmo):
         url = self.urls['api']['ws']['public']
         messageHash = 'orderbook:' + symbol
         params = self.omit(params, 'aggregation')
-        subscribe = {
+        subscribe: dict = {
             'method': 'subscribe',
             'id': self.request_id(),
             'topics': [
@@ -537,7 +537,7 @@ class exmo(ccxt.async_support.exmo):
         #     "topic": "spot/ticker:BTC_USDT"
         # }
         event = self.safe_string(message, 'event')
-        events = {
+        events: dict = {
             'logged_in': self.handle_authentication_message,
             'info': self.handle_info,
             'subscribed': self.handle_subscribed,
@@ -551,7 +551,7 @@ class exmo(ccxt.async_support.exmo):
             if topic is not None:
                 parts = topic.split(':')
                 channel = self.safe_string(parts, 0)
-                handlers = {
+                handlers: dict = {
                     'spot/ticker': self.handle_ticker,
                     'spot/wallet': self.handle_balance,
                     'margin/wallet': self.handle_balance,
@@ -617,7 +617,7 @@ class exmo(ccxt.async_support.exmo):
             requestId = self.request_id()
             signData = self.apiKey + str(time)
             sign = self.hmac(self.encode(signData), self.encode(self.secret), hashlib.sha512, 'base64')
-            request = {
+            request: dict = {
                 'method': 'login',
                 'id': requestId,
                 'api_key': self.apiKey,

ccxt/pro/gate.py

@@ -122,7 +122,7 @@ class gate(ccxt.async_support.gate):
         if market['contract']:
             stringLimit = str(limit)
             payload.append(stringLimit)
-        subscription = {
+        subscription: dict = {
             'symbol': symbol,
             'limit': limit,
         }
@@ -357,7 +357,7 @@ class gate(ccxt.async_support.gate):
             messageHashes.append(prefix + ':' + symbol)
         tickerOrBidAsk = await self.subscribe_public_multiple(url, messageHashes, marketIds, channel, params)
         if self.newUpdates:
-            items = {}
+            items: dict = {}
             items[tickerOrBidAsk['symbol']] = tickerOrBidAsk
             return items
         result = self.tickers if isWatchTickers else self.bidsasks
@@ -509,7 +509,7 @@ class gate(ccxt.async_support.gate):
         result = self.safe_value(message, 'result')
         if not isinstance(result, list):
             result = [result]
-        marketIds = {}
+        marketIds: dict = {}
         for i in range(0, len(result)):
             ohlcv = result[i]
             subscription = self.safe_string(ohlcv, 'n', '')
@@ -608,7 +608,7 @@ class gate(ccxt.async_support.gate):
             cachedTrades = ArrayCacheBySymbolById(limit)
             self.myTrades = cachedTrades
         parsed = self.parse_trades(result)
-        marketIds = {}
+        marketIds: dict = {}
         for i in range(0, len(parsed)):
             trade = parsed[i]
             cachedTrades.append(trade)
@@ -939,7 +939,7 @@ class gate(ccxt.async_support.gate):
         if self.orders is None:
             self.orders = ArrayCacheBySymbolById(limit)
         stored = self.orders
-        marketIds = {}
+        marketIds: dict = {}
         parsedOrders = self.parse_orders(orders)
         for i in range(0, len(parsedOrders)):
             parsed = parsedOrders[i]
@@ -1003,7 +1003,7 @@ class gate(ccxt.async_support.gate):
 
     def handle_subscription_status(self, client: Client, message):
         channel = self.safe_string(message, 'channel')
-        methods = {
+        methods: dict = {
             'balance': self.handle_balance_subscription,
             'spot.order_book_update': self.handle_order_book_subscription,
             'futures.order_book_update': self.handle_order_book_subscription,
@@ -1116,7 +1116,7 @@ class gate(ccxt.async_support.gate):
         channel = self.safe_string(message, 'channel', '')
         channelParts = channel.split('.')
         channelType = self.safe_value(channelParts, 1)
-        v4Methods = {
+        v4Methods: dict = {
             'usertrades': self.handle_my_trades,
             'candlesticks': self.handle_ohlcv,
             'orders': self.handle_order,
@@ -1155,7 +1155,7 @@ class gate(ccxt.async_support.gate):
             return url
 
     def get_market_type_by_url(self, url: str):
-        findBy = {
+        findBy: dict = {
             'op-': 'option',
             'delivery': 'future',
             'fx': 'swap',
@@ -1177,7 +1177,7 @@ class gate(ccxt.async_support.gate):
     async def subscribe_public(self, url, messageHash, payload, channel, params={}, subscription=None):
         requestId = self.request_id()
         time = self.seconds()
-        request = {
+        request: dict = {
             'id': requestId,
             'time': time,
             'channel': channel,
@@ -1195,7 +1195,7 @@ class gate(ccxt.async_support.gate):
     async def subscribe_public_multiple(self, url, messageHashes, payload, channel, params={}):
         requestId = self.request_id()
         time = self.seconds()
-        request = {
+        request: dict = {
             'id': requestId,
             'time': time,
             'channel': channel,
@@ -1220,13 +1220,13 @@ class gate(ccxt.async_support.gate):
         event = 'subscribe'
         signaturePayload = 'channel=' + channel + '&' + 'event=' + event + '&' + 'time=' + str(time)
         signature = self.hmac(self.encode(signaturePayload), self.encode(self.secret), hashlib.sha512, 'hex')
-        auth = {
+        auth: dict = {
             'method': 'api_key',
             'KEY': self.apiKey,
             'SIGN': signature,
         }
         requestId = self.request_id()
-        request = {
+        request: dict = {
             'id': requestId,
             'time': time,
             'channel': channel,

ccxt/pro/gemini.py

@@ -56,7 +56,7 @@ class gemini(ccxt.async_support.gemini):
         market = self.market(symbol)
         messageHash = 'trades:' + market['symbol']
         marketId = market['id']
-        request = {
+        request: dict = {
             'type': 'subscribe',
             'subscriptions': [
                 {
@@ -225,7 +225,7 @@ class gemini(ccxt.async_support.gemini):
     def handle_trades_for_multidata(self, client: Client, trades, timestamp: Int):
         if trades is not None:
             tradesLimit = self.safe_integer(self.options, 'tradesLimit', 1000)
-            storesForSymbols = {}
+            storesForSymbols: dict = {}
             for i in range(0, len(trades)):
                 marketId = trades[i]['symbol']
                 market = self.safe_market(marketId.lower())
@@ -260,7 +260,7 @@ class gemini(ccxt.async_support.gemini):
         await self.load_markets()
         market = self.market(symbol)
         timeframeId = self.safe_string(self.timeframes, timeframe, timeframe)
-        request = {
+        request: dict = {
             'type': 'subscribe',
             'subscriptions': [
                 {
@@ -344,7 +344,7 @@ class gemini(ccxt.async_support.gemini):
         market = self.market(symbol)
         messageHash = 'orderbook:' + market['symbol']
         marketId = market['id']
-        request = {
+        request: dict = {
             'type': 'subscribe',
             'subscriptions': [
                 {
@@ -580,7 +580,7 @@ class gemini(ccxt.async_support.gemini):
         """
         url = self.urls['api']['ws'] + '/v1/order/events?eventTypeFilter=initial&eventTypeFilter=accepted&eventTypeFilter=rejected&eventTypeFilter=fill&eventTypeFilter=cancelled&eventTypeFilter=booked'
         await self.load_markets()
-        authParams = {
+        authParams: dict = {
             'url': url,
         }
         await self.authenticate(authParams)
@@ -714,7 +714,7 @@ class gemini(ccxt.async_support.gemini):
         }, market)
 
     def parse_ws_order_status(self, status):
-        statuses = {
+        statuses: dict = {
             'accepted': 'open',
             'booked': 'open',
             'fill': 'closed',
@@ -725,7 +725,7 @@ class gemini(ccxt.async_support.gemini):
         return self.safe_string(statuses, status, status)
 
     def parse_ws_order_type(self, type):
-        types = {
+        types: dict = {
             'exchange limit': 'limit',
             'market buy': 'market',
             'market sell': 'market',
@@ -784,7 +784,7 @@ class gemini(ccxt.async_support.gemini):
         reason = self.safe_string(message, 'reason')
         if reason == 'error':
             self.handle_error(client, message)
-        methods = {
+        methods: dict = {
             'l2_updates': self.handle_l2_updates,
             'trade': self.handle_trade,
             'subscription_ack': self.handle_subscription,
@@ -838,13 +838,13 @@ class gemini(ccxt.async_support.gemini):
         urlLength = len(url)
         endIndex = urlParamsIndex if (urlParamsIndex >= 0) else urlLength
         request = url[startIndex:endIndex]
-        payload = {
+        payload: dict = {
             'request': request,
             'nonce': self.nonce(),
         }
         b64 = self.string_to_base64(self.json(payload))
         signature = self.hmac(self.encode(b64), self.encode(self.secret), hashlib.sha384, 'hex')
-        defaultOptions = {
+        defaultOptions: dict = {
             'ws': {
                 'options': {
                     'headers': {},
@@ -854,7 +854,7 @@ class gemini(ccxt.async_support.gemini):
         # self.options = self.extend(defaultOptions, self.options)
         self.extend_exchange_options(defaultOptions)
         originalHeaders = self.options['ws']['options']['headers']
-        headers = {
+        headers: dict = {
             'X-GEMINI-APIKEY': self.apiKey,
             'X-GEMINI-PAYLOAD': b64,
             'X-GEMINI-SIGNATURE': signature,