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

ccxt/woofipro.py

@@ -539,7 +539,7 @@ class woofipro(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: an associative dictionary of currencies
         """
-        result = {}
+        result: dict = {}
         response = self.v1PublicGetPublicToken(params)
         #
         # {
@@ -571,7 +571,7 @@ class woofipro(Exchange, ImplicitAPI):
             networks = self.safe_list(token, 'chain_details')
             code = self.safe_currency_code(currencyId)
             minPrecision = None
-            resultingNetworks = {}
+            resultingNetworks: dict = {}
             for j in range(0, len(networks)):
                 network = networks[j]
                 # TODO: transform chain id to human readable name
@@ -635,7 +635,7 @@ class woofipro(Exchange, ImplicitAPI):
             }
         return fee
 
-    def parse_trade(self, trade, market: Market = None) -> Trade:
+    def parse_trade(self, trade: dict, market: Market = None) -> Trade:
         #
         # public/market_trades
         #
@@ -707,7 +707,7 @@ class woofipro(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         if limit is not None:
@@ -780,7 +780,7 @@ class woofipro(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         response = self.v1PublicGetPublicFundingRateSymbol(self.extend(request, params))
@@ -852,7 +852,7 @@ class woofipro(Exchange, ImplicitAPI):
         paginate, params = self.handle_option_and_params(params, 'fetchFundingRateHistory', 'paginate')
         if paginate:
             return self.fetch_paginated_call_incremental('fetchFundingRateHistory', symbol, since, limit, params, 'page', 25)
-        request = {}
+        request: dict = {}
         if symbol is not None:
             market = self.market(symbol)
             symbol = market['symbol']
@@ -936,7 +936,7 @@ class woofipro(Exchange, ImplicitAPI):
         data = self.safe_dict(response, 'data', {})
         maker = self.safe_string(data, 'futures_maker_fee_rate')
         taker = self.safe_string(data, 'futures_taker_fee_rate')
-        result = {}
+        result: dict = {}
         for i in range(0, len(self.symbols)):
             symbol = self.symbols[i]
             result[symbol] = {
@@ -960,7 +960,7 @@ class woofipro(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         if limit is not None:
@@ -1011,7 +1011,7 @@ class woofipro(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
             'type': self.safe_string(self.timeframes, timeframe, timeframe),
         }
@@ -1042,7 +1042,7 @@ class woofipro(Exchange, ImplicitAPI):
         rows = self.safe_list(data, 'rows', [])
         return self.parse_ohlcvs(rows, market, timeframe, since, limit)
 
-    def parse_order(self, order, market: Market = None) -> Order:
+    def parse_order(self, order: dict, market: Market = None) -> Order:
         #
         # Possible input functions:
         # * createOrder
@@ -1155,17 +1155,17 @@ class woofipro(Exchange, ImplicitAPI):
             'info': order,
         }, market)
 
-    def parse_time_in_force(self, timeInForce):
-        timeInForces = {
+    def parse_time_in_force(self, timeInForce: Str):
+        timeInForces: dict = {
             'ioc': 'IOC',
             'fok': 'FOK',
             'post_only': 'PO',
         }
         return self.safe_string(timeInForces, timeInForce, None)
 
-    def parse_order_status(self, status):
+    def parse_order_status(self, status: Str):
         if status is not None:
-            statuses = {
+            statuses: dict = {
                 'NEW': 'open',
                 'FILLED': 'closed',
                 'CANCEL_SENT': 'canceled',
@@ -1179,8 +1179,8 @@ class woofipro(Exchange, ImplicitAPI):
             return self.safe_string(statuses, status, status)
         return status
 
-    def parse_order_type(self, type):
-        types = {
+    def parse_order_type(self, type: Str):
+        types: dict = {
             'LIMIT': 'limit',
             'MARKET': 'market',
             'POST_ONLY': 'limit',
@@ -1203,7 +1203,7 @@ class woofipro(Exchange, ImplicitAPI):
         orderType = type.upper()
         market = self.market(symbol)
         orderSide = side.upper()
-        request = {
+        request: dict = {
             'symbol': market['id'],
             'side': orderSide,
         }
@@ -1242,7 +1242,7 @@ class woofipro(Exchange, ImplicitAPI):
             request['algo_type'] = 'STOP'
         elif (stopLoss is not None) or (takeProfit is not None):
             request['algo_type'] = 'TP_SL'
-            outterOrder = {
+            outterOrder: dict = {
                 'symbol': market['id'],
                 'reduce_only': False,
                 'algo_type': 'POSITIONAL_TP_SL',
@@ -1251,7 +1251,7 @@ class woofipro(Exchange, ImplicitAPI):
             closeSide = 'SELL' if (orderSide == 'BUY') else 'BUY'
             if stopLoss is not None:
                 stopLossPrice = self.safe_number_2(stopLoss, 'triggerPrice', 'price', stopLoss)
-                stopLossOrder = {
+                stopLossOrder: dict = {
                     'side': closeSide,
                     'algo_type': 'TP_SL',
                     'trigger_price': self.price_to_precision(symbol, stopLossPrice),
@@ -1261,7 +1261,7 @@ class woofipro(Exchange, ImplicitAPI):
                 outterOrder['child_orders'].append(stopLossOrder)
             if takeProfit is not None:
                 takeProfitPrice = self.safe_number_2(takeProfit, 'triggerPrice', 'price', takeProfit)
-                takeProfitOrder = {
+                takeProfitOrder: dict = {
                     'side': closeSide,
                     'algo_type': 'TP_SL',
                     'trigger_price': self.price_to_precision(symbol, takeProfitPrice),
@@ -1364,7 +1364,7 @@ class woofipro(Exchange, ImplicitAPI):
                 raise NotSupported(self.id + 'createOrders() only support non-stop order')
             orderRequest = self.create_order_request(marketId, type, side, amount, price, orderParams)
             ordersRequests.append(orderRequest)
-        request = {
+        request: dict = {
             'orders': ordersRequests,
         }
         response = self.v1PrivatePostBatchOrder(self.extend(request, params))
@@ -1408,7 +1408,7 @@ class woofipro(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'order_id': id,
         }
         stopPrice = self.safe_string_n(params, ['triggerPrice', 'stopPrice', 'takeProfitPrice', 'stopLossPrice'])
@@ -1482,7 +1482,7 @@ class woofipro(Exchange, ImplicitAPI):
         market: Market = None
         if symbol is not None:
             market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         clientOrderIdUnified = self.safe_string_2(params, 'clOrdID', 'clientOrderId')
@@ -1520,7 +1520,7 @@ class woofipro(Exchange, ImplicitAPI):
         #     "status": "CANCEL_SENT"
         # }
         #
-        extendParams = {'symbol': symbol}
+        extendParams: dict = {'symbol': symbol}
         if isByClientOrder:
             extendParams['client_order_id'] = clientOrderIdExchangeSpecific
         else:
@@ -1544,7 +1544,7 @@ class woofipro(Exchange, ImplicitAPI):
         self.load_markets()
         clientOrderIds = self.safe_list_n(params, ['clOrdIDs', 'clientOrderIds', 'client_order_ids'])
         params = self.omit(params, ['clOrdIDs', 'clientOrderIds', 'client_order_ids'])
-        request = {}
+        request: dict = {}
         response = None
         if clientOrderIds:
             request['client_order_ids'] = ','.join(clientOrderIds)
@@ -1576,7 +1576,7 @@ class woofipro(Exchange, ImplicitAPI):
         self.load_markets()
         stop = self.safe_bool_2(params, 'stop', 'trigger')
         params = self.omit(params, ['stop', 'trigger'])
-        request = {}
+        request: dict = {}
         if symbol is not None:
             market = self.market(symbol)
             request['symbol'] = market['id']
@@ -1618,7 +1618,7 @@ class woofipro(Exchange, ImplicitAPI):
         self.load_markets()
         market = self.market(symbol) if (symbol is not None) else None
         stop = self.safe_bool_2(params, 'stop', 'trigger', False)
-        request = {}
+        request: dict = {}
         clientOrderId = self.safe_string_n(params, ['clOrdID', 'clientOrderId', 'client_order_id'])
         params = self.omit(params, ['stop', 'trigger', 'clOrdID', 'clientOrderId', 'client_order_id'])
         response = None
@@ -1689,7 +1689,7 @@ class woofipro(Exchange, ImplicitAPI):
         paginate, params = self.handle_option_and_params(params, 'fetchOrders', 'paginate')
         if paginate:
             return self.fetch_paginated_call_incremental('fetchOrders', symbol, since, limit, params, 'page', maxLimit)
-        request = {}
+        request: dict = {}
         market: Market = None
         params = self.omit(params, ['stop', 'trigger'])
         if symbol is not None:
@@ -1802,7 +1802,7 @@ class woofipro(Exchange, ImplicitAPI):
         market: Market = None
         if symbol is not None:
             market = self.market(symbol)
-        request = {
+        request: dict = {
             'oid': id,
         }
         response = self.v1PrivateGetOrderOidTrades(self.extend(request, params))
@@ -1848,7 +1848,7 @@ class woofipro(Exchange, ImplicitAPI):
         paginate, params = self.handle_option_and_params(params, 'fetchMyTrades', 'paginate')
         if paginate:
             return self.fetch_paginated_call_incremental('fetchMyTrades', symbol, since, limit, params, 'page', 500)
-        request = {}
+        request: dict = {}
         market: Market = None
         if symbol is not None:
             market = self.market(symbol)
@@ -1892,7 +1892,7 @@ class woofipro(Exchange, ImplicitAPI):
         return self.parse_trades(trades, market, since, limit, params)
 
     def parse_balance(self, response) -> Balances:
-        result = {
+        result: dict = {
             'info': response,
         }
         balances = self.safe_list(response, 'holding', [])
@@ -1934,7 +1934,7 @@ class woofipro(Exchange, ImplicitAPI):
 
     def get_asset_history_rows(self, code: Str = None, since: Int = None, limit: Int = None, params={}) -> Any:
         self.load_markets()
-        request = {}
+        request: dict = {}
         currency: Currency = None
         if code is not None:
             currency = self.currency(code)
@@ -1976,7 +1976,7 @@ class woofipro(Exchange, ImplicitAPI):
         data = self.safe_dict(response, 'data', {})
         return [currency, self.safe_list(data, 'rows', [])]
 
-    def parse_ledger_entry(self, item, currency: Currency = None):
+    def parse_ledger_entry(self, item: dict, currency: Currency = None):
         code = self.safe_string(item, 'token')
         amount = self.safe_number(item, 'amount')
         side = self.safe_string(item, 'token_side')
@@ -2002,7 +2002,7 @@ class woofipro(Exchange, ImplicitAPI):
         }
 
     def parse_ledger_entry_type(self, type):
-        types = {
+        types: dict = {
             'BALANCE': 'transaction',  # Funds moved in/out wallet
             'COLLATERAL': 'transfer',  # Funds moved between portfolios
         }
@@ -2021,7 +2021,7 @@ class woofipro(Exchange, ImplicitAPI):
         currency, rows = self.get_asset_history_rows(code, since, limit, params)
         return self.parse_ledger(rows, currency, since, limit, params)
 
-    def parse_transaction(self, transaction, currency: Currency = None) -> Transaction:
+    def parse_transaction(self, transaction: dict, currency: Currency = None) -> Transaction:
         # example in fetchLedger
         code = self.safe_string(transaction, 'token')
         movementDirection = self.safe_string_lower(transaction, 'token_side')
@@ -2055,7 +2055,7 @@ class woofipro(Exchange, ImplicitAPI):
         }
 
     def parse_transaction_status(self, status):
-        statuses = {
+        statuses: dict = {
             'NEW': 'pending',
             'CONFIRMING': 'pending',
             'PROCESSING': 'pending',
@@ -2074,7 +2074,7 @@ class woofipro(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: a list of `transaction structures <https://docs.ccxt.com/#/?id=transaction-structure>`
         """
-        request = {
+        request: dict = {
             'side': 'DEPOSIT',
         }
         return self.fetch_deposits_withdrawals(code, since, limit, self.extend(request, params))
@@ -2089,7 +2089,7 @@ class woofipro(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: a list of `transaction structures <https://docs.ccxt.com/#/?id=transaction-structure>`
         """
-        request = {
+        request: dict = {
             'side': 'WITHDRAW',
         }
         return self.fetch_deposits_withdrawals(code, since, limit, self.extend(request, params))
@@ -2104,7 +2104,7 @@ class woofipro(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a list of `transaction structure <https://docs.ccxt.com/#/?id=transaction-structure>`
         """
-        request = {}
+        request: dict = {}
         currency, rows = self.get_asset_history_rows(code, since, limit, self.extend(request, params))
         #
         #     {
@@ -2171,13 +2171,13 @@ class woofipro(Exchange, ImplicitAPI):
             raise BadRequest(self.id + ' withdraw() require chainId parameter')
         withdrawNonce = self.get_withdraw_nonce(params)
         nonce = self.nonce()
-        domain = {
+        domain: dict = {
             'chainId': chainId,
             'name': 'Orderly',
             'verifyingContract': verifyingContractAddress,
             'version': '1',
         }
-        messageTypes = {
+        messageTypes: dict = {
             'Withdraw': [
                 {'name': 'brokerId', 'type': 'string'},
                 {'name': 'chainId', 'type': 'uint256'},
@@ -2188,7 +2188,7 @@ class woofipro(Exchange, ImplicitAPI):
                 {'name': 'timestamp', 'type': 'uint64'},
             ],
         }
-        withdrawRequest = {
+        withdrawRequest: dict = {
             'brokerId': self.safe_string(self.options, 'keyBrokerId', 'woofi_pro'),
             'chainId': self.parse_to_int(chainId),
             'receiver': address,
@@ -2199,7 +2199,7 @@ class woofipro(Exchange, ImplicitAPI):
         }
         msg = self.eth_encode_structured_data(domain, messageTypes, withdrawRequest)
         signature = self.sign_message(msg, self.privateKey)
-        request = {
+        request: dict = {
             'signature': signature,
             'userAddress': address,
             'verifyingContract': verifyingContractAddress,
@@ -2281,12 +2281,12 @@ class woofipro(Exchange, ImplicitAPI):
         self.load_markets()
         if (leverage < 1) or (leverage > 50):
             raise BadRequest(self.id + ' leverage should be between 1 and 50')
-        request = {
+        request: dict = {
             'leverage': leverage,
         }
         return self.v1PrivatePostClientLeverage(self.extend(request, params))
 
-    def parse_position(self, position, market: Market = None):
+    def parse_position(self, position: dict, market: Market = None):
         #
         # {
         #     "IMR_withdraw_orders": 0.1,
@@ -2365,7 +2365,7 @@ class woofipro(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'symbol': market['id'],
         }
         response = self.v1PrivateGetPositionSymbol(self.extend(request, params))

ccxt/yobit.py

@@ -297,7 +297,7 @@ class yobit(Exchange, ImplicitAPI):
     def parse_balance(self, response) -> Balances:
         balances = self.safe_dict(response, 'return', {})
         timestamp = self.safe_integer(balances, 'server_time')
-        result = {
+        result: dict = {
             'info': response,
             'timestamp': timestamp,
             'datetime': self.iso8601(timestamp),
@@ -455,7 +455,7 @@ class yobit(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'pair': market['id'],
         }
         if limit is not None:
@@ -487,14 +487,14 @@ class yobit(Exchange, ImplicitAPI):
         else:
             ids = self.market_ids(symbols)
             ids = '-'.join(ids)
-        request = {
+        request: dict = {
             'pair': ids,
             # 'ignore_invalid': True,
         }
         if limit is not None:
             request['limit'] = limit
         response = self.publicGetDepthPair(self.extend(request, params))
-        result = {}
+        result: dict = {}
         ids = list(response.keys())
         for i in range(0, len(ids)):
             id = ids[i]
@@ -566,11 +566,11 @@ class yobit(Exchange, ImplicitAPI):
         actualLength = len(idsString) + lenghtOfBaseUrl
         if actualLength > maxLength:
             raise ArgumentsRequired(self.id + ' fetchTickers() is being requested for ' + str(idsLength) + ' markets(which has an URL length of ' + str(actualLength) + ' characters), but it exceedes max URL length(' + str(maxLength) + '), please pass limisted symbols array to fetchTickers to fit in one request')
-        request = {
+        request: dict = {
             'pair': idsString,
         }
         tickers = self.publicGetTickerPair(self.extend(request, params))
-        result = {}
+        result: dict = {}
         keys = list(tickers.keys())
         for k in range(0, len(keys)):
             id = keys[k]
@@ -591,7 +591,7 @@ class yobit(Exchange, ImplicitAPI):
         tickers = self.fetch_tickers([symbol], params)
         return tickers[symbol]
 
-    def parse_trade(self, trade, market: Market = None) -> Trade:
+    def parse_trade(self, trade: dict, market: Market = None) -> Trade:
         #
         # fetchTrades(public)
         #
@@ -677,7 +677,7 @@ class yobit(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'pair': market['id'],
         }
         if limit is not None:
@@ -733,7 +733,7 @@ class yobit(Exchange, ImplicitAPI):
         #
         pairs = self.safe_dict(response, 'pairs', {})
         marketIds = list(pairs.keys())
-        result = {}
+        result: dict = {}
         for i in range(0, len(marketIds)):
             marketId = marketIds[i]
             pair = self.safe_dict(pairs, marketId, {})
@@ -768,7 +768,7 @@ class yobit(Exchange, ImplicitAPI):
             raise ExchangeError(self.id + ' createOrder() allows limit orders only')
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'pair': market['id'],
             'type': side,
             'amount': self.amount_to_precision(symbol, amount),
@@ -809,7 +809,7 @@ class yobit(Exchange, ImplicitAPI):
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.load_markets()
-        request = {
+        request: dict = {
             'order_id': int(id),
         }
         response = self.privatePostCancelOrder(self.extend(request, params))
@@ -835,8 +835,8 @@ class yobit(Exchange, ImplicitAPI):
         result = self.safe_dict(response, 'return', {})
         return self.parse_order(result)
 
-    def parse_order_status(self, status):
-        statuses = {
+    def parse_order_status(self, status: Str):
+        statuses: dict = {
             '0': 'open',
             '1': 'closed',
             '2': 'canceled',
@@ -844,7 +844,7 @@ class yobit(Exchange, ImplicitAPI):
         }
         return self.safe_string(statuses, status, status)
 
-    def parse_order(self, order, market: Market = None) -> Order:
+    def parse_order(self, order: dict, market: Market = None) -> Order:
         #
         # createOrder(private)
         #
@@ -955,7 +955,7 @@ class yobit(Exchange, ImplicitAPI):
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         self.load_markets()
-        request = {
+        request: dict = {
             'order_id': int(id),
         }
         response = self.privatePostOrderInfo(self.extend(request, params))
@@ -992,7 +992,7 @@ class yobit(Exchange, ImplicitAPI):
         if symbol is None:
             raise ArgumentsRequired(self.id + ' fetchOpenOrders() requires a symbol argument')
         self.load_markets()
-        request = {}
+        request: dict = {}
         market = None
         if symbol is not None:
             marketInner = self.market(symbol)
@@ -1039,7 +1039,7 @@ class yobit(Exchange, ImplicitAPI):
         self.load_markets()
         market = self.market(symbol)
         # some derived classes use camelcase notation for request fields
-        request = {
+        request: dict = {
             # 'from': 123456789,  # trade ID, from which the display starts numerical 0(test result: liqui ignores self field)
             # 'count': 1000,  # the number of trades for display numerical, default = 1000
             # 'from_id': trade ID, from which the display starts numerical 0
@@ -1089,7 +1089,7 @@ class yobit(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: an `address structure <https://docs.ccxt.com/#/?id=address-structure>`
         """
-        request = {
+        request: dict = {
             'need_new': 1,
         }
         response = self.fetch_deposit_address(code, self.extend(request, params))
@@ -1120,7 +1120,7 @@ class yobit(Exchange, ImplicitAPI):
             if network != 'ERC20':
                 currencyId = currencyId + network.lower()
             params = self.omit(params, 'network')
-        request = {
+        request: dict = {
             'coinName': currencyId,
             'need_new': 0,
         }
@@ -1168,7 +1168,7 @@ class yobit(Exchange, ImplicitAPI):
         self.check_address(address)
         self.load_markets()
         currency = self.currency(code)
-        request = {
+        request: dict = {
             'coinName': currency['id'],
             'amount': amount,
             'address': address,

ccxt/zaif.py

@@ -234,7 +234,7 @@ class zaif(Exchange, ImplicitAPI):
     def parse_balance(self, response) -> Balances:
         balances = self.safe_value(response, 'return', {})
         deposit = self.safe_value(balances, 'deposit')
-        result = {
+        result: dict = {
             'info': response,
             'timestamp': None,
             'datetime': None,
@@ -276,7 +276,7 @@ class zaif(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'pair': market['id'],
         }
         response = self.publicGetDepthPair(self.extend(request, params))
@@ -332,7 +332,7 @@ class zaif(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'pair': market['id'],
         }
         ticker = self.publicGetTickerPair(self.extend(request, params))
@@ -349,7 +349,7 @@ class zaif(Exchange, ImplicitAPI):
         #
         return self.parse_ticker(ticker, market)
 
-    def parse_trade(self, trade, market: Market = None) -> Trade:
+    def parse_trade(self, trade: dict, market: Market = None) -> Trade:
         #
         # fetchTrades(public)
         #
@@ -398,7 +398,7 @@ class zaif(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'pair': market['id'],
         }
         response = self.publicGetTradesPair(self.extend(request, params))
@@ -437,7 +437,7 @@ class zaif(Exchange, ImplicitAPI):
         if type != 'limit':
             raise ExchangeError(self.id + ' createOrder() allows limit orders only')
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'currency_pair': market['id'],
             'action': 'bid' if (side == 'buy') else 'ask',
             'amount': amount,
@@ -458,12 +458,12 @@ class zaif(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
-        request = {
+        request: dict = {
             'order_id': id,
         }
         return self.privatePostCancelOrder(self.extend(request, params))
 
-    def parse_order(self, order, market: Market = None) -> Order:
+    def parse_order(self, order: dict, market: Market = None) -> Order:
         #
         #     {
         #         "currency_pair": "btc_jpy",
@@ -519,7 +519,7 @@ class zaif(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market: Market = None
-        request = {
+        request: dict = {
             # 'is_token': False,
             # 'is_token_both': False,
         }
@@ -541,7 +541,7 @@ class zaif(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market: Market = None
-        request = {
+        request: dict = {
             # 'from': 0,
             # 'count': 1000,
             # 'from_id': 0,
@@ -574,7 +574,7 @@ class zaif(Exchange, ImplicitAPI):
         currency = self.currency(code)
         if code == 'JPY':
             raise ExchangeError(self.id + ' withdraw() does not allow ' + code + ' withdrawals')
-        request = {
+        request: dict = {
             'currency': currency['id'],
             'amount': amount,
             'address': address,
@@ -603,7 +603,7 @@ class zaif(Exchange, ImplicitAPI):
         returnData = self.safe_dict(result, 'return')
         return self.parse_transaction(returnData, currency)
 
-    def parse_transaction(self, transaction, currency: Currency = None) -> Transaction:
+    def parse_transaction(self, transaction: dict, currency: Currency = None) -> Transaction:
         #
         #     {
         #         "id": 23634,