ccxt 4.3.66__py2.py3-none-any.whl → 4.3.67__py2.py3-none-any.whl

ccxt/__init__.py

@@ -22,7 +22,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.3.66'
+__version__ = '4.3.67'
 
 # ----------------------------------------------------------------------------
 

ccxt/abstract/bingx.py

@@ -85,13 +85,20 @@ class ImplicitAPI:
     cswap_v1_private_get_trade_leverage = cswapV1PrivateGetTradeLeverage = Entry('trade/leverage', ['cswap', 'v1', 'private'], 'GET', {'cost': 2})
     cswap_v1_private_get_trade_forceorders = cswapV1PrivateGetTradeForceOrders = Entry('trade/forceOrders', ['cswap', 'v1', 'private'], 'GET', {'cost': 2})
     cswap_v1_private_get_trade_allfillorders = cswapV1PrivateGetTradeAllFillOrders = Entry('trade/allFillOrders', ['cswap', 'v1', 'private'], 'GET', {'cost': 2})
+    cswap_v1_private_get_trade_openorders = cswapV1PrivateGetTradeOpenOrders = Entry('trade/openOrders', ['cswap', 'v1', 'private'], 'GET', {'cost': 2})
+    cswap_v1_private_get_trade_orderdetail = cswapV1PrivateGetTradeOrderDetail = Entry('trade/orderDetail', ['cswap', 'v1', 'private'], 'GET', {'cost': 2})
+    cswap_v1_private_get_trade_orderhistory = cswapV1PrivateGetTradeOrderHistory = Entry('trade/orderHistory', ['cswap', 'v1', 'private'], 'GET', {'cost': 2})
+    cswap_v1_private_get_trade_margintype = cswapV1PrivateGetTradeMarginType = Entry('trade/marginType', ['cswap', 'v1', 'private'], 'GET', {'cost': 2})
     cswap_v1_private_get_user_commissionrate = cswapV1PrivateGetUserCommissionRate = Entry('user/commissionRate', ['cswap', 'v1', 'private'], 'GET', {'cost': 2})
     cswap_v1_private_get_user_positions = cswapV1PrivateGetUserPositions = Entry('user/positions', ['cswap', 'v1', 'private'], 'GET', {'cost': 2})
     cswap_v1_private_get_user_balance = cswapV1PrivateGetUserBalance = Entry('user/balance', ['cswap', 'v1', 'private'], 'GET', {'cost': 2})
     cswap_v1_private_post_trade_order = cswapV1PrivatePostTradeOrder = Entry('trade/order', ['cswap', 'v1', 'private'], 'POST', {'cost': 2})
     cswap_v1_private_post_trade_leverage = cswapV1PrivatePostTradeLeverage = Entry('trade/leverage', ['cswap', 'v1', 'private'], 'POST', {'cost': 2})
     cswap_v1_private_post_trade_closeallpositions = cswapV1PrivatePostTradeCloseAllPositions = Entry('trade/closeAllPositions', ['cswap', 'v1', 'private'], 'POST', {'cost': 2})
+    cswap_v1_private_post_trade_margintype = cswapV1PrivatePostTradeMarginType = Entry('trade/marginType', ['cswap', 'v1', 'private'], 'POST', {'cost': 2})
+    cswap_v1_private_post_trade_positionmargin = cswapV1PrivatePostTradePositionMargin = Entry('trade/positionMargin', ['cswap', 'v1', 'private'], 'POST', {'cost': 2})
     cswap_v1_private_delete_trade_allopenorders = cswapV1PrivateDeleteTradeAllOpenOrders = Entry('trade/allOpenOrders', ['cswap', 'v1', 'private'], 'DELETE', {'cost': 2})
+    cswap_v1_private_delete_trade_cancelorder = cswapV1PrivateDeleteTradeCancelOrder = Entry('trade/cancelOrder', ['cswap', 'v1', 'private'], 'DELETE', {'cost': 2})
     contract_v1_private_get_allposition = contractV1PrivateGetAllPosition = Entry('allPosition', ['contract', 'v1', 'private'], 'GET', {'cost': 2})
     contract_v1_private_get_allorders = contractV1PrivateGetAllOrders = Entry('allOrders', ['contract', 'v1', 'private'], 'GET', {'cost': 2})
     contract_v1_private_get_balance = contractV1PrivateGetBalance = Entry('balance', ['contract', 'v1', 'private'], 'GET', {'cost': 2})

ccxt/async_support/__init__.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.3.66'
+__version__ = '4.3.67'
 
 # -----------------------------------------------------------------------------
 

ccxt/async_support/base/exchange.py

@@ -2,7 +2,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.3.66'
+__version__ = '4.3.67'
 
 # -----------------------------------------------------------------------------
 

ccxt/async_support/bingx.py

@@ -298,6 +298,10 @@ class bingx(Exchange, ImplicitAPI):
                                 'trade/leverage': 2,
                                 'trade/forceOrders': 2,
                                 'trade/allFillOrders': 2,
+                                'trade/openOrders': 2,
+                                'trade/orderDetail': 2,
+                                'trade/orderHistory': 2,
+                                'trade/marginType': 2,
                                 'user/commissionRate': 2,
                                 'user/positions': 2,
                                 'user/balance': 2,
@@ -306,9 +310,12 @@ class bingx(Exchange, ImplicitAPI):
                                 'trade/order': 2,
                                 'trade/leverage': 2,
                                 'trade/closeAllPositions': 2,
+                                'trade/marginType': 2,
+                                'trade/positionMargin': 2,
                             },
                             'delete': {
                                 'trade/allOpenOrders': 2,
+                                'trade/cancelOrder': 2,
                             },
                         },
                     },
@@ -2835,7 +2842,8 @@ class bingx(Exchange, ImplicitAPI):
         #        "clientOrderID": ""
         #    }
         #
-        # inverse swap cancelAllOrders
+        # inverse swap cancelAllOrders, cancelOrder
+        # inverse swap cancelAllOrders, cancelOrder, fetchOpenOrders
         #
         #     {
         #         "symbol": "SOL-USD",
@@ -2979,13 +2987,14 @@ class bingx(Exchange, ImplicitAPI):
     async def cancel_order(self, id: str, symbol: Str = None, params={}):
         """
         cancels an open order
-        :see: https://bingx-api.github.io/docs/#/spot/trade-api.html#Cancel%20an%20Order
-        :see: https://bingx-api.github.io/docs/#/swapV2/trade-api.html#Cancel%20an%20Order
+        :see: https://bingx-api.github.io/docs/#/en-us/spot/trade-api.html#Cancel%20Order
+        :see: https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Cancel%20Order
+        :see: https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Cancel%20an%20Order
         :param str id: order id
         :param str symbol: unified symbol of the market the order was made in
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param str [params.clientOrderId]: a unique id for the order
-        :returns dict: An `order structure <https://docs.ccxt.com/#/?id=order-structure>`
+        :returns dict: an `order structure <https://docs.ccxt.com/#/?id=order-structure>`
         """
         if symbol is None:
             raise ArgumentsRequired(self.id + ' cancelOrder() requires a symbol argument')
@@ -3001,11 +3010,17 @@ class bingx(Exchange, ImplicitAPI):
         else:
             request['orderId'] = id
         response = None
-        marketType, query = self.handle_market_type_and_params('cancelOrder', market, params)
-        if marketType == 'spot':
-            response = await self.spotV1PrivatePostTradeCancel(self.extend(request, query))
+        type = None
+        subType = None
+        type, params = self.handle_market_type_and_params('cancelOrder', market, params)
+        subType, params = self.handle_sub_type_and_params('cancelOrder', market, params)
+        if type == 'spot':
+            response = await self.spotV1PrivatePostTradeCancel(self.extend(request, params))
         else:
-            response = await self.swapV2PrivateDeleteTradeOrder(self.extend(request, query))
+            if subType == 'inverse':
+                response = await self.cswapV1PrivateDeleteTradeCancelOrder(self.extend(request, params))
+            else:
+                response = await self.swapV2PrivateDeleteTradeOrder(self.extend(request, params))
         #
         # spot
         #
@@ -3025,7 +3040,59 @@ class bingx(Exchange, ImplicitAPI):
         #       }
         #   }
         #
-        # swap
+        # inverse swap
+        #
+        #     {
+        #         "code": 0,
+        #         "msg": "",
+        #         "data": {
+        #             "order": {
+        #                 "symbol": "SOL-USD",
+        #                 "orderId": "1816002957423951872",
+        #                 "side": "BUY",
+        #                 "positionSide": "Long",
+        #                 "type": "Pending",
+        #                 "quantity": 0,
+        #                 "origQty": "0",
+        #                 "price": "150",
+        #                 "executedQty": "0",
+        #                 "avgPrice": "0",
+        #                 "cumQuote": "0",
+        #                 "stopPrice": "",
+        #                 "profit": "0.0000",
+        #                 "commission": "0.000000",
+        #                 "status": "CANCELLED",
+        #                 "time": 1721803819410,
+        #                 "updateTime": 1721803819427,
+        #                 "clientOrderId": "",
+        #                 "leverage": "",
+        #                 "takeProfit": {
+        #                     "type": "",
+        #                     "quantity": 0,
+        #                     "stopPrice": 0,
+        #                     "price": 0,
+        #                     "workingType": "",
+        #                     "stopGuaranteed": ""
+        #                 },
+        #                 "stopLoss": {
+        #                     "type": "",
+        #                     "quantity": 0,
+        #                     "stopPrice": 0,
+        #                     "price": 0,
+        #                     "workingType": "",
+        #                     "stopGuaranteed": ""
+        #                 },
+        #                 "advanceAttr": 0,
+        #                 "positionID": 0,
+        #                 "takeProfitEntrustPrice": 0,
+        #                 "stopLossEntrustPrice": 0,
+        #                 "orderType": "",
+        #                 "workingType": ""
+        #             }
+        #         }
+        #     }
+        #
+        # linear swap
         #
         #    {
         #        "code": 0,
@@ -3052,9 +3119,9 @@ class bingx(Exchange, ImplicitAPI):
         #        }
         #    }
         #
-        data = self.safe_value(response, 'data')
-        first = self.safe_dict(data, 'order', data)
-        return self.parse_order(first, market)
+        data = self.safe_dict(response, 'data', {})
+        order = self.safe_dict(data, 'order', data)
+        return self.parse_order(order, market)
 
     async def cancel_all_orders(self, symbol: Str = None, params={}):
         """
@@ -3498,9 +3565,10 @@ class bingx(Exchange, ImplicitAPI):
 
     async def fetch_open_orders(self, symbol: Str = None, since: Int = None, limit: Int = None, params={}) -> List[Order]:
         """
-        :see: https://bingx-api.github.io/docs/#/spot/trade-api.html#Query%20Open%20Orders
-        :see: https://bingx-api.github.io/docs/#/swapV2/trade-api.html#Query%20all%20current%20pending%20orders
         fetch all unfilled currently open orders
+        :see: https://bingx-api.github.io/docs/#/en-us/spot/trade-api.html#Current%20Open%20Orders
+        :see: https://bingx-api.github.io/docs/#/en-us/swapV2/trade-api.html#Current%20All%20Open%20Orders
+        :see: https://bingx-api.github.io/docs/#/en-us/cswap/trade-api.html#Query%20all%20current%20pending%20orders
         :param str symbol: unified market symbol
         :param int [since]: the earliest time in ms to fetch open orders for
         :param int [limit]: the maximum number of open order structures to retrieve
@@ -3513,12 +3581,18 @@ class bingx(Exchange, ImplicitAPI):
         if symbol is not None:
             market = self.market(symbol)
             request['symbol'] = market['id']
+        type = None
+        subType = None
         response = None
-        marketType, query = self.handle_market_type_and_params('fetchOpenOrders', market, params)
-        if marketType == 'spot':
-            response = await self.spotV1PrivateGetTradeOpenOrders(self.extend(request, query))
+        type, params = self.handle_market_type_and_params('fetchOpenOrders', market, params)
+        subType, params = self.handle_sub_type_and_params('fetchOpenOrders', market, params)
+        if type == 'spot':
+            response = await self.spotV1PrivateGetTradeOpenOrders(self.extend(request, params))
         else:
-            response = await self.swapV2PrivateGetTradeOpenOrders(self.extend(request, query))
+            if subType == 'inverse':
+                response = await self.cswapV1PrivateGetTradeOpenOrders(self.extend(request, params))
+            else:
+                response = await self.swapV2PrivateGetTradeOpenOrders(self.extend(request, params))
         #
         #  spot
         #
@@ -3545,7 +3619,61 @@ class bingx(Exchange, ImplicitAPI):
         #        }
         #    }
         #
-        # swap
+        # inverse swap
+        #
+        #     {
+        #         "code": 0,
+        #         "msg": "",
+        #         "data": {
+        #             "orders": [
+        #                 {
+        #                     "symbol": "SOL-USD",
+        #                     "orderId": "1816013900044320768",
+        #                     "side": "BUY",
+        #                     "positionSide": "Long",
+        #                     "type": "LIMIT",
+        #                     "quantity": 1,
+        #                     "origQty": "",
+        #                     "price": "150",
+        #                     "executedQty": "0",
+        #                     "avgPrice": "0.000",
+        #                     "cumQuote": "",
+        #                     "stopPrice": "",
+        #                     "profit": "0.0000",
+        #                     "commission": "0.0000",
+        #                     "status": "Pending",
+        #                     "time": 1721806428334,
+        #                     "updateTime": 1721806428352,
+        #                     "clientOrderId": "",
+        #                     "leverage": "",
+        #                     "takeProfit": {
+        #                         "type": "TAKE_PROFIT",
+        #                         "quantity": 0,
+        #                         "stopPrice": 0,
+        #                         "price": 0,
+        #                         "workingType": "MARK_PRICE",
+        #                         "stopGuaranteed": ""
+        #                     },
+        #                     "stopLoss": {
+        #                         "type": "STOP",
+        #                         "quantity": 0,
+        #                         "stopPrice": 0,
+        #                         "price": 0,
+        #                         "workingType": "MARK_PRICE",
+        #                         "stopGuaranteed": ""
+        #                     },
+        #                     "advanceAttr": 0,
+        #                     "positionID": 0,
+        #                     "takeProfitEntrustPrice": 0,
+        #                     "stopLossEntrustPrice": 0,
+        #                     "orderType": "",
+        #                     "workingType": "MARK_PRICE"
+        #                 }
+        #             ]
+        #         }
+        #     }
+        #
+        # linear swap
         #
         #    {
         #        "code": 0,

ccxt/async_support/bithumb.py

@@ -5,6 +5,7 @@
 
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.bithumb import ImplicitAPI
+import asyncio
 import hashlib
 from ccxt.base.types import Balances, Currency, Int, Market, MarketInterface, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction
 from typing import List
@@ -212,17 +213,56 @@ class bithumb(Exchange, ImplicitAPI):
         :returns dict[]: an array of objects representing market data
         """
         result = []
-        quoteCurrencies = self.safe_value(self.options, 'quoteCurrencies', {})
+        quoteCurrencies = self.safe_dict(self.options, 'quoteCurrencies', {})
         quotes = list(quoteCurrencies.keys())
+        promises = []
+        for i in range(0, len(quotes)):
+            request = {
+                'quoteId': quotes[i],
+            }
+            promises.append(self.publicGetTickerALLQuoteId(self.extend(request, params)))
+            #
+            #    {
+            #        "status": "0000",
+            #        "data": {
+            #            "ETH": {
+            #                "opening_price": "0.05153399",
+            #                "closing_price": "0.05145144",
+            #                "min_price": "0.05145144",
+            #                "max_price": "0.05160781",
+            #                "units_traded": "6.541124172077830855",
+            #                "acc_trade_value": "0.33705472498492329997697755",
+            #                "prev_closing_price": "0.0515943",
+            #                "units_traded_24H": "43.368879902677400513",
+            #                "acc_trade_value_24H": "2.24165339555398079994373342",
+            #                "fluctate_24H": "-0.00018203",
+            #                "fluctate_rate_24H": "-0.35"
+            #            },
+            #            "XRP": {
+            #                "opening_price": "0.00000918",
+            #                "closing_price": "0.0000092",
+            #                "min_price": "0.00000918",
+            #                "max_price": "0.0000092",
+            #                "units_traded": "6516.949363",
+            #                "acc_trade_value": "0.0598792533602796",
+            #                "prev_closing_price": "0.00000916",
+            #                "units_traded_24H": "229161.50354738",
+            #                "acc_trade_value_24H": "2.0446589371637117",
+            #                "fluctate_24H": "0.00000049",
+            #                "fluctate_rate_24H": "5.63"
+            #            },
+            #            ...
+            #            "date": "1721675913145"
+            #        }
+            #    }
+            #
+        results = await asyncio.gather(*promises)
         for i in range(0, len(quotes)):
             quote = quotes[i]
             quoteId = quote
-            extension = self.safe_value(quoteCurrencies, quote, {})
-            request: dict = {
-                'quoteId': quoteId,
-            }
-            response = await self.publicGetTickerALLQuoteId(self.extend(request, params))
-            data = self.safe_value(response, 'data')
+            response = results[i]
+            data = self.safe_dict(response, 'data')
+            extension = self.safe_dict(quoteCurrencies, quote, {})
             currencyIds = list(data.keys())
             for j in range(0, len(currencyIds)):
                 currencyId = currencyIds[j]
@@ -286,7 +326,7 @@ class bithumb(Exchange, ImplicitAPI):
 
     def parse_balance(self, response) -> Balances:
         result: dict = {'info': response}
-        balances = self.safe_value(response, 'data')
+        balances = self.safe_dict(response, 'data')
         codes = list(self.currencies.keys())
         for i in range(0, len(codes)):
             code = codes[i]
@@ -351,7 +391,7 @@ class bithumb(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        data = self.safe_value(response, 'data', {})
+        data = self.safe_dict(response, 'data', {})
         timestamp = self.safe_integer(data, 'timestamp')
         return self.parse_order_book(data, symbol, timestamp, 'bids', 'asks', 'price', 'quantity')
 
@@ -413,15 +453,18 @@ class bithumb(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         result: dict = {}
-        quoteCurrencies = self.safe_value(self.options, 'quoteCurrencies', {})
+        quoteCurrencies = self.safe_dict(self.options, 'quoteCurrencies', {})
         quotes = list(quoteCurrencies.keys())
+        promises = []
         for i in range(0, len(quotes)):
-            quote = quotes[i]
-            quoteId = quote
             request: dict = {
-                'quoteId': quoteId,
+                'quoteId': quotes[i],
             }
-            response = await self.publicGetTickerALLQuoteId(self.extend(request, params))
+            promises.append(self.publicGetTickerALLQuoteId(self.extend(request, params)))
+        responses = await asyncio.gather(*promises)
+        for i in range(0, len(quotes)):
+            quote = quotes[i]
+            response = responses[i]
             #
             #     {
             #         "status":"0000",
@@ -443,7 +486,7 @@ class bithumb(Exchange, ImplicitAPI):
             #         }
             #     }
             #
-            data = self.safe_value(response, 'data', {})
+            data = self.safe_dict(response, 'data', {})
             timestamp = self.safe_integer(data, 'date')
             tickers = self.omit(data, 'date')
             currencyIds = list(tickers.keys())
@@ -805,7 +848,7 @@ class bithumb(Exchange, ImplicitAPI):
         #     }
         #
         timestamp = self.safe_integer_product(order, 'order_date', 0.001)
-        sideProperty = self.safe_value_2(order, 'type', 'side')
+        sideProperty = self.safe_string_2(order, 'type', 'side')
         side = 'buy' if (sideProperty == 'bid') else 'sell'
         status = self.parse_order_status(self.safe_string(order, 'order_status'))
         price = self.safe_string_2(order, 'order_price', 'price')
@@ -830,7 +873,7 @@ class bithumb(Exchange, ImplicitAPI):
             market = self.safe_market(None, market)
             symbol = market['symbol']
         id = self.safe_string(order, 'order_id')
-        rawTrades = self.safe_value(order, 'contract', [])
+        rawTrades = self.safe_list(order, 'contract', [])
         return self.safe_order({
             'info': order,
             'id': id,

ccxt/async_support/whitebit.py

@@ -2404,7 +2404,7 @@ class whitebit(Exchange, ImplicitAPI):
         records = self.safe_list(response, 'records')
         return self.parse_transactions(records, currency, since, limit)
 
-    def is_fiat(self, currency: str):
+    def is_fiat(self, currency: str) -> bool:
         fiatCurrencies = self.safe_value(self.options, 'fiatCurrencies', [])
         return self.in_array(currency, fiatCurrencies)
 

ccxt/async_support/zonda.py

@@ -1467,7 +1467,7 @@ class zonda(Exchange, ImplicitAPI):
         # {status: "Ok", errors: []}
         return self.parse_order(response)
 
-    def is_fiat(self, currency: str):
+    def is_fiat(self, currency: str) -> bool:
         fiatCurrencies: dict = {
             'USD': True,
             'EUR': True,

ccxt/base/exchange.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.3.66'
+__version__ = '4.3.67'
 
 # -----------------------------------------------------------------------------
 
@@ -2225,7 +2225,7 @@ class Exchange(object):
     def parse_transfer(self, transfer: dict, currency: Currency = None):
         raise NotSupported(self.id + ' parseTransfer() is not supported yet')
 
-    def parse_account(self, account):
+    def parse_account(self, account: dict):
         raise NotSupported(self.id + ' parseAccount() is not supported yet')
 
     def parse_ledger_entry(self, item: dict, currency: Currency = None):
@@ -2462,7 +2462,7 @@ class Exchange(object):
             },
         }, currency)
 
-    def safe_market_structure(self, market=None):
+    def safe_market_structure(self, market: dict = None):
         cleanStructure = {
             'id': None,
             'lowercaseId': None,
@@ -2622,7 +2622,7 @@ class Exchange(object):
         superWithRestDescribe = self.deep_extend(extendedRestDescribe, wsBaseDescribe)
         return superWithRestDescribe
 
-    def safe_balance(self, balance: object):
+    def safe_balance(self, balance: dict):
         balances = self.omit(balance, ['info', 'timestamp', 'datetime', 'free', 'used', 'total'])
         codes = list(balances.keys())
         balance['free'] = {}
@@ -2656,7 +2656,7 @@ class Exchange(object):
             balance['debt'] = debtBalance
         return balance
 
-    def safe_order(self, order: object, market: Market = None):
+    def safe_order(self, order: dict, market: Market = None):
         # parses numbers
         # * it is important pass the trades rawTrades
         amount = self.omit_zero(self.safe_string(order, 'amount'))
@@ -2961,7 +2961,7 @@ class Exchange(object):
             'cost': self.parse_number(cost),
         }
 
-    def safe_liquidation(self, liquidation: object, market: Market = None):
+    def safe_liquidation(self, liquidation: dict, market: Market = None):
         contracts = self.safe_string(liquidation, 'contracts')
         contractSize = self.safe_string(market, 'contractSize')
         price = self.safe_string(liquidation, 'price')
@@ -2978,7 +2978,7 @@ class Exchange(object):
         liquidation['quoteValue'] = self.parse_number(quoteValue)
         return liquidation
 
-    def safe_trade(self, trade: object, market: Market = None):
+    def safe_trade(self, trade: dict, market: Market = None):
         amount = self.safe_string(trade, 'amount')
         price = self.safe_string(trade, 'price')
         cost = self.safe_string(trade, 'cost')
@@ -3120,7 +3120,7 @@ class Exchange(object):
             result = self.array_concat(result, reducedFeeValues)
         return result
 
-    def safe_ticker(self, ticker: object, market: Market = None):
+    def safe_ticker(self, ticker: dict, market: Market = None):
         open = self.omit_zero(self.safe_string(ticker, 'open'))
         close = self.omit_zero(self.safe_string(ticker, 'close'))
         last = self.omit_zero(self.safe_string(ticker, 'last'))
@@ -3553,7 +3553,7 @@ class Exchange(object):
                 self.options['limitsLoaded'] = self.milliseconds()
         return self.markets
 
-    def safe_position(self, position):
+    def safe_position(self, position: dict):
         # simplified version of: /pull/12765/
         unrealizedPnlString = self.safe_string(position, 'unrealisedPnl')
         initialMarginString = self.safe_string(position, 'initialMargin')
@@ -5721,7 +5721,7 @@ class Exchange(object):
             params = self.omit(params, ['until', 'till'])
         return [request, params]
 
-    def safe_open_interest(self, interest, market: Market = None):
+    def safe_open_interest(self, interest: dict, market: Market = None):
         symbol = self.safe_string(interest, 'symbol')
         if symbol is None:
             symbol = self.safe_string(market, 'symbol')