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

ccxt/async_support/coinex.py

@@ -6,7 +6,7 @@
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.coinex import ImplicitAPI
 import asyncio
-from ccxt.base.types import Balances, Currencies, Currency, Int, IsolatedBorrowRate, Leverage, Leverages, MarginModification, Market, Num, Order, OrderRequest, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, Trade, TradingFeeInterface, TradingFees, Transaction, TransferEntry, TransferEntries
+from ccxt.base.types import Balances, Currencies, Currency, Int, IsolatedBorrowRate, Leverage, LeverageTier, LeverageTiers, MarginModification, Market, Num, Order, OrderRequest, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, Trade, TradingFeeInterface, TradingFees, Transaction, TransferEntry, TransferEntries
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
@@ -82,8 +82,8 @@ class coinex(Exchange, ImplicitAPI):
                 'fetchDepositAddressByNetwork': False,
                 'fetchDepositAddresses': False,
                 'fetchDeposits': True,
-                'fetchDepositWithdrawFee': 'emulated',
-                'fetchDepositWithdrawFees': True,
+                'fetchDepositWithdrawFee': True,
+                'fetchDepositWithdrawFees': False,
                 'fetchFundingHistory': True,
                 'fetchFundingRate': True,
                 'fetchFundingRateHistory': True,
@@ -91,8 +91,8 @@ class coinex(Exchange, ImplicitAPI):
                 'fetchIndexOHLCV': False,
                 'fetchIsolatedBorrowRate': True,
                 'fetchIsolatedBorrowRates': False,
-                'fetchLeverage': 'emulated',
-                'fetchLeverages': True,
+                'fetchLeverage': True,
+                'fetchLeverages': False,
                 'fetchLeverageTiers': True,
                 'fetchMarginAdjustmentHistory': True,
                 'fetchMarketLeverageTiers': 'emulated',
@@ -567,7 +567,7 @@ class coinex(Exchange, ImplicitAPI):
         #
         data = self.safe_value(response, 'data', [])
         coins = list(data.keys())
-        result = {}
+        result: dict = {}
         for i in range(0, len(coins)):
             coin = coins[i]
             currency = data[coin]
@@ -628,7 +628,7 @@ class coinex(Exchange, ImplicitAPI):
             if precisionString is not None:
                 minPrecisionString = precisionString if (minPrecisionString is None) else Precise.string_min(precisionString, minPrecisionString)
             networks = self.safe_value(result[code], 'networks', {})
-            network = {
+            network: dict = {
                 'info': currency,
                 'id': networkId,
                 'network': networkId,
@@ -936,7 +936,7 @@ class coinex(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'market': market['id'],
         }
         response = None
@@ -1100,7 +1100,7 @@ class coinex(Exchange, ImplicitAPI):
         market = self.market(symbol)
         if limit is None:
             limit = 20  # default
-        request = {
+        request: dict = {
             'market': market['id'],
             'limit': limit,
             'interval': '0',
@@ -1165,7 +1165,7 @@ class coinex(Exchange, ImplicitAPI):
         timestamp = self.safe_integer(depth, 'updated_at')
         return self.parse_order_book(depth, symbol, timestamp)
 
-    def parse_trade(self, trade, market: Market = None) -> Trade:
+    def parse_trade(self, trade: dict, market: Market = None) -> Trade:
         #
         # Spot and Swap fetchTrades(public)
         #
@@ -1237,7 +1237,7 @@ class coinex(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'market': market['id'],
             # 'last_id': 0,
         }
@@ -1278,7 +1278,7 @@ class coinex(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'market': market['id'],
         }
         response = None
@@ -1389,7 +1389,7 @@ class coinex(Exchange, ImplicitAPI):
             #     }
             #
         data = self.safe_list(response, 'data', [])
-        result = {}
+        result: dict = {}
         for i in range(0, len(data)):
             entry = data[i]
             marketId = self.safe_string(entry, 'market')
@@ -1398,7 +1398,7 @@ class coinex(Exchange, ImplicitAPI):
             result[symbol] = self.parse_trading_fee(entry, market)
         return result
 
-    def parse_trading_fee(self, fee, market: Market = None) -> TradingFeeInterface:
+    def parse_trading_fee(self, fee: dict, market: Market = None) -> TradingFeeInterface:
         marketId = self.safe_value(fee, 'market')
         symbol = self.safe_symbol(marketId, market)
         return {
@@ -1446,7 +1446,7 @@ class coinex(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'market': market['id'],
             'period': self.safe_string(self.timeframes, timeframe, timeframe),
         }
@@ -1514,7 +1514,7 @@ class coinex(Exchange, ImplicitAPI):
         #         "message": "OK"
         #     }
         #
-        result = {'info': response}
+        result: dict = {'info': response}
         balances = self.safe_list(response, 'data', [])
         for i in range(0, len(balances)):
             entry = balances[i]
@@ -1549,7 +1549,7 @@ class coinex(Exchange, ImplicitAPI):
         #         "message": "OK"
         #     }
         #
-        result = {'info': response}
+        result: dict = {'info': response}
         balances = self.safe_list(response, 'data', [])
         for i in range(0, len(balances)):
             entry = balances[i]
@@ -1580,7 +1580,7 @@ class coinex(Exchange, ImplicitAPI):
         #         "message": "OK"
         #     }
         #
-        result = {'info': response}
+        result: dict = {'info': response}
         balances = self.safe_list(response, 'data', [])
         for i in range(0, len(balances)):
             entry = balances[i]
@@ -1608,7 +1608,7 @@ class coinex(Exchange, ImplicitAPI):
         #         "message": "OK"
         #     }
         #
-        result = {'info': response}
+        result: dict = {'info': response}
         balances = self.safe_list(response, 'data', [])
         for i in range(0, len(balances)):
             entry = balances[i]
@@ -1646,8 +1646,8 @@ class coinex(Exchange, ImplicitAPI):
         else:
             return await self.fetch_spot_balance(params)
 
-    def parse_order_status(self, status):
-        statuses = {
+    def parse_order_status(self, status: Str):
+        statuses: dict = {
             'rejected': 'rejected',
             'open': 'open',
             'not_deal': 'open',
@@ -1657,7 +1657,7 @@ class coinex(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:
         #
         # Spot and Margin createOrder, createOrders, editOrder, cancelOrders, cancelOrder, fetchOpenOrders
         #
@@ -1952,7 +1952,7 @@ class coinex(Exchange, ImplicitAPI):
         if reduceOnly:
             if not market['swap']:
                 raise InvalidOrder(self.id + ' createOrder() does not support reduceOnly for ' + market['type'] + ' orders, reduceOnly orders are supported for swap markets only')
-        request = {
+        request: dict = {
             'market': market['id'],
         }
         if clientOrderId is None:
@@ -2298,7 +2298,7 @@ class coinex(Exchange, ImplicitAPI):
             orderRequest = self.create_order_request(marketId, type, side, amount, price, orderParams)
             ordersRequests.append(orderRequest)
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'market': market['id'],
             'orders': ordersRequests,
         }
@@ -2457,7 +2457,7 @@ class coinex(Exchange, ImplicitAPI):
             raise ArgumentsRequired(self.id + ' cancelOrders() requires a symbol argument')
         await self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'market': market['id'],
         }
         stop = self.safe_bool_2(params, 'stop', 'trigger')
@@ -2632,7 +2632,7 @@ class coinex(Exchange, ImplicitAPI):
             raise ArgumentsRequired(self.id + ' editOrder() requires a symbol argument')
         await self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'market': market['id'],
         }
         if amount is not None:
@@ -2768,7 +2768,7 @@ class coinex(Exchange, ImplicitAPI):
         market = self.market(symbol)
         isTriggerOrder = self.safe_bool_2(params, 'stop', 'trigger')
         swap = market['swap']
-        request = {
+        request: dict = {
             'market': market['id'],
         }
         marginMode = None
@@ -3039,7 +3039,7 @@ class coinex(Exchange, ImplicitAPI):
             raise ArgumentsRequired(self.id + ' cancelAllOrders() requires a symbol argument')
         await self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'market': market['id'],
         }
         response = None
@@ -3075,7 +3075,7 @@ class coinex(Exchange, ImplicitAPI):
             raise ArgumentsRequired(self.id + ' fetchOrder() requires a symbol argument')
         await self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'market': market['id'],
             'order_id': self.parse_to_numeric(id),
         }
@@ -3161,7 +3161,7 @@ class coinex(Exchange, ImplicitAPI):
         :returns Order[]: a list of `order structures <https://docs.ccxt.com/#/?id=order-structure>`
         """
         await self.load_markets()
-        request = {}
+        request: dict = {}
         market = None
         if symbol is not None:
             market = self.market(symbol)
@@ -3497,7 +3497,7 @@ class coinex(Exchange, ImplicitAPI):
         if network is None:
             raise ArgumentsRequired(self.id + ' createDepositAddress() requires a network parameter')
         params = self.omit(params, 'network')
-        request = {
+        request: dict = {
             'ccy': currency['id'],
             'chain': self.network_code_to_id(network, currency['code']),
         }
@@ -3536,7 +3536,7 @@ class coinex(Exchange, ImplicitAPI):
                 raise ArgumentsRequired(self.id + ' fetchDepositAddress() ' + code + ' requires a network parameter')
             if not (network in networks):
                 raise ExchangeError(self.id + ' fetchDepositAddress() ' + network + ' network not supported for ' + code)
-        request = {
+        request: dict = {
             'ccy': currency['id'],
             'chain': network,
         }
@@ -3616,7 +3616,7 @@ class coinex(Exchange, ImplicitAPI):
             raise ArgumentsRequired(self.id + ' fetchMyTrades() requires a symbol argument')
         await self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'market': market['id'],
         }
         if limit is not None:
@@ -3694,7 +3694,7 @@ class coinex(Exchange, ImplicitAPI):
         defaultMethod = None
         defaultMethod, params = self.handle_option_and_params(params, 'fetchPositions', 'method', 'v2PrivateGetFuturesPendingPosition')
         symbols = self.market_symbols(symbols)
-        request = {
+        request: dict = {
             'market_type': 'FUTURES',
         }
         market = None
@@ -3773,7 +3773,7 @@ class coinex(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'market_type': 'FUTURES',
             'market': market['id'],
         }
@@ -3824,7 +3824,7 @@ class coinex(Exchange, ImplicitAPI):
         data = self.safe_list(response, 'data', [])
         return self.parse_position(data[0], market)
 
-    def parse_position(self, position, market: Market = None):
+    def parse_position(self, position: dict, market: Market = None):
         #
         #     {
         #         "position_id": 305891033,
@@ -3918,7 +3918,7 @@ class coinex(Exchange, ImplicitAPI):
             raise ArgumentsRequired(self.id + ' setMarginMode() requires a leverage parameter')
         if (leverage < 1) or (leverage > maxLeverage):
             raise BadRequest(self.id + ' setMarginMode() leverage should be between 1 and ' + str(maxLeverage) + ' for ' + symbol)
-        request = {
+        request: dict = {
             'market': market['id'],
             'market_type': 'FUTURES',
             'margin_mode': marginMode,
@@ -3958,7 +3958,7 @@ class coinex(Exchange, ImplicitAPI):
         maxLeverage = self.safe_integer(market['limits']['leverage'], 'max', 100)
         if (leverage < minLeverage) or (leverage > maxLeverage):
             raise BadRequest(self.id + ' setLeverage() leverage should be between ' + str(minLeverage) + ' and ' + str(maxLeverage) + ' for ' + symbol)
-        request = {
+        request: dict = {
             'market': market['id'],
             'market_type': 'FUTURES',
             'margin_mode': marginMode,
@@ -3976,7 +3976,7 @@ class coinex(Exchange, ImplicitAPI):
         #     }
         #
 
-    async def fetch_leverage_tiers(self, symbols: Strings = None, params={}):
+    async def fetch_leverage_tiers(self, symbols: Strings = None, params={}) -> LeverageTiers:
         """
         retrieve information on the maximum leverage, and maintenance margin for trades of varying trade sizes
         :see: https://docs.coinex.com/api/v2/futures/market/http/list-market-position-level
@@ -3985,7 +3985,7 @@ class coinex(Exchange, ImplicitAPI):
         :returns dict: a dictionary of `leverage tiers structures <https://docs.ccxt.com/#/?id=leverage-tiers-structure>`, indexed by market symbols
         """
         await self.load_markets()
-        request = {}
+        request: dict = {}
         if symbols is not None:
             marketIds = self.market_ids(symbols)
             request['market'] = ','.join(marketIds)
@@ -4018,7 +4018,7 @@ class coinex(Exchange, ImplicitAPI):
         data = self.safe_list(response, 'data', [])
         return self.parse_leverage_tiers(data, symbols, 'market')
 
-    def parse_market_leverage_tiers(self, info, market: Market = None):
+    def parse_market_leverage_tiers(self, info, market: Market = None) -> List[LeverageTier]:
         tiers = []
         brackets = self.safe_list(info, 'level', [])
         minNotional = 0
@@ -4046,7 +4046,7 @@ class coinex(Exchange, ImplicitAPI):
         requestAmount = rawAmount
         if addOrReduce == 'reduce':
             requestAmount = Precise.string_neg(rawAmount)
-        request = {
+        request: dict = {
             'market': market['id'],
             'market_type': 'FUTURES',
             'amount': requestAmount,
@@ -4205,7 +4205,7 @@ class coinex(Exchange, ImplicitAPI):
             raise ArgumentsRequired(self.id + ' fetchFundingHistory() requires a symbol argument')
         await self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'market': market['id'],
             'market_type': 'FUTURES',
         }
@@ -4266,7 +4266,7 @@ class coinex(Exchange, ImplicitAPI):
         market = self.market(symbol)
         if not market['swap']:
             raise BadSymbol(self.id + ' fetchFundingRate() supports swap contracts only')
-        request = {
+        request: dict = {
             'market': market['id'],
         }
         response = await self.v2PublicGetFuturesFundingRate(self.extend(request, params))
@@ -4340,7 +4340,7 @@ class coinex(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         symbols = self.market_symbols(symbols)
-        request = {}
+        request: dict = {}
         market = None
         if symbols is not None:
             symbol = self.safe_value(symbols, 0)
@@ -4392,7 +4392,7 @@ class coinex(Exchange, ImplicitAPI):
         params = self.omit(params, 'network')
         if tag:
             address = address + ':' + tag
-        request = {
+        request: dict = {
             'coin_type': currency['id'],
             'coin_address': address,  # must be authorized, inter-user transfer by a registered mobile phone number or an email address is supported
             'actual_amount': float(self.number_to_string(amount)),  # the actual amount without fees, https://www.coinex.com/fees
@@ -4423,7 +4423,7 @@ class coinex(Exchange, ImplicitAPI):
         return self.parse_transaction(transaction, currency)
 
     def parse_transaction_status(self, status):
-        statuses = {
+        statuses: dict = {
             'audit': 'pending',
             'pass': 'pending',
             'processing': 'pending',
@@ -4455,7 +4455,7 @@ class coinex(Exchange, ImplicitAPI):
         if paginate:
             return await self.fetch_paginated_call_deterministic('fetchFundingRateHistory', symbol, since, limit, '8h', params, 1000)
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'market': market['id'],
         }
         if since is not None:
@@ -4498,7 +4498,7 @@ class coinex(Exchange, ImplicitAPI):
         sorted = self.sort_by(rates, 'timestamp')
         return self.filter_by_symbol_since_limit(sorted, market['symbol'], since, limit)
 
-    def parse_transaction(self, transaction, currency: Currency = None) -> Transaction:
+    def parse_transaction(self, transaction: dict, currency: Currency = None) -> Transaction:
         #
         # fetchDeposits
         #
@@ -4615,7 +4615,7 @@ class coinex(Exchange, ImplicitAPI):
         accountsByType = self.safe_dict(self.options, 'accountsById', {})
         fromId = self.safe_string(accountsByType, fromAccount, fromAccount)
         toId = self.safe_string(accountsByType, toAccount, toAccount)
-        request = {
+        request: dict = {
             'ccy': currency['id'],
             'amount': amountToPrecision,
             'from_account_type': fromId,
@@ -4644,7 +4644,7 @@ class coinex(Exchange, ImplicitAPI):
         })
 
     def parse_transfer_status(self, status):
-        statuses = {
+        statuses: dict = {
             '0': 'ok',
             'SUCCESS': 'ok',
             'OK': 'ok',
@@ -4685,7 +4685,7 @@ class coinex(Exchange, ImplicitAPI):
         if code is None:
             raise ArgumentsRequired(self.id + ' fetchTransfers() requires a code argument')
         currency = self.currency(code)
-        request = {
+        request: dict = {
             'ccy': currency['id'],
         }
         marginMode = None
@@ -4734,7 +4734,7 @@ class coinex(Exchange, ImplicitAPI):
         :returns dict[]: a list of `transaction structures <https://docs.ccxt.com/#/?id=transaction-structure>`
         """
         await self.load_markets()
-        request = {}
+        request: dict = {}
         currency = None
         if code is not None:
             currency = self.currency(code)
@@ -4788,7 +4788,7 @@ class coinex(Exchange, ImplicitAPI):
         :returns dict[]: a list of `transaction structures <https://docs.ccxt.com/#/?id=transaction-structure>`
         """
         await self.load_markets()
-        request = {}
+        request: dict = {}
         currency = None
         if code is not None:
             currency = self.currency(code)
@@ -4877,7 +4877,7 @@ class coinex(Exchange, ImplicitAPI):
         params = self.omit(params, 'code')
         currency = self.currency(code)
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'market': market['id'],
             'ccy': currency['id'],
         }
@@ -4911,7 +4911,7 @@ class coinex(Exchange, ImplicitAPI):
         :returns dict[]: a list of `borrow interest structures <https://docs.ccxt.com/#/?id=borrow-interest-structure>`
         """
         await self.load_markets()
-        request = {}
+        request: dict = {}
         market = None
         if symbol is not None:
             market = self.market(symbol)
@@ -4947,7 +4947,7 @@ class coinex(Exchange, ImplicitAPI):
         interest = self.parse_borrow_interests(rows, market)
         return self.filter_by_currency_since_limit(interest, code, since, limit)
 
-    def parse_borrow_interest(self, info, market: Market = None):
+    def parse_borrow_interest(self, info: dict, market: Market = None):
         #
         #     {
         #         "borrow_id": 2642934,
@@ -4995,7 +4995,7 @@ class coinex(Exchange, ImplicitAPI):
         currency = self.currency(code)
         isAutoRenew = self.safe_bool_2(params, 'isAutoRenew', 'is_auto_renew', False)
         params = self.omit(params, 'isAutoRenew')
-        request = {
+        request: dict = {
             'market': market['id'],
             'ccy': currency['id'],
             'borrow_amount': self.currency_to_precision(code, amount),
@@ -5039,7 +5039,7 @@ class coinex(Exchange, ImplicitAPI):
         await self.load_markets()
         market = self.market(symbol)
         currency = self.currency(code)
-        request = {
+        request: dict = {
             'market': market['id'],
             'ccy': currency['id'],
             'amount': self.currency_to_precision(code, amount),
@@ -5085,143 +5085,176 @@ class coinex(Exchange, ImplicitAPI):
             'info': info,
         }
 
-    async def fetch_deposit_withdraw_fees(self, codes: Strings = None, params={}):
+    async def fetch_deposit_withdraw_fee(self, code: str, params={}):
         """
-        fetch deposit and withdraw fees
-        :see: https://viabtc.github.io/coinex_api_en_doc/spot/#docsspot001_market010_asset_config
-        :param str[]|None codes: list of unified currency codes
+        fetch the fee for deposits and withdrawals
+        :see: https://docs.coinex.com/api/v2/assets/deposit-withdrawal/http/get-deposit-withdrawal-config
+        :param str code: unified currency code
         :param dict [params]: extra parameters specific to the exchange API endpoint
-        :returns dict[]: a list of `fees structures <https://docs.ccxt.com/#/?id=fee-structure>`
+        :returns dict: a `fee structure <https://docs.ccxt.com/#/?id=fee-structure>`
         """
         await self.load_markets()
-        request = {}
-        if codes is not None:
-            codesLength = len(codes)
-            if codesLength == 1:
-                request['coin_type'] = self.safe_value(codes, 0)
-        response = await self.v1PublicGetCommonAssetConfig(self.extend(request, params))
-        #
-        #    {
-        #        "code": 0,
-        #        "data": {
-        #            "CET-CSC": {
-        #                "asset": "CET",
-        #                "chain": "CSC",
-        #                "can_deposit": True,
-        #                "can_withdraw ": False,
-        #                "deposit_least_amount": "1",
-        #                "withdraw_least_amount": "1",
-        #                "withdraw_tx_fee": "0.1"
-        #            },
-        #            "CET-ERC20": {
-        #                "asset": "CET",
-        #                "chain": "ERC20",
-        #                "can_deposit": True,
-        #                "can_withdraw": False,
-        #                "deposit_least_amount": "14",
-        #                "withdraw_least_amount": "14",
-        #                "withdraw_tx_fee": "14"
-        #            }
-        #        },
-        #        "message": "Success"
-        #    }
-        #
-        return self.parse_deposit_withdraw_fees(response, codes)
+        currency = self.currency(code)
+        request: dict = {
+            'ccy': currency['id'],
+        }
+        response = await self.v2PrivateGetAssetsDepositWithdrawConfig(self.extend(request, params))
+        #
+        #     {
+        #         "code": 0,
+        #         "data": {
+        #             "asset": {
+        #                 "ccy": "USDT",
+        #                 "deposit_enabled": True,
+        #                 "withdraw_enabled": True,
+        #                 "inter_transfer_enabled": True,
+        #                 "is_st": False
+        #             },
+        #             "chains": [
+        #                 {
+        #                     "chain": "TRC20",
+        #                     "min_deposit_amount": "2.4",
+        #                     "min_withdraw_amount": "2.4",
+        #                     "deposit_enabled": True,
+        #                     "withdraw_enabled": True,
+        #                     "deposit_delay_minutes": 0,
+        #                     "safe_confirmations": 10,
+        #                     "irreversible_confirmations": 20,
+        #                     "deflation_rate": "0",
+        #                     "withdrawal_fee": "2.4",
+        #                     "withdrawal_precision": 6,
+        #                     "memo": "",
+        #                     "is_memo_required_for_deposit": False,
+        #                     "explorer_asset_url": "https://tronscan.org/#/token20/TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t"
+        #                 },
+        #             ]
+        #         },
+        #         "message": "OK"
+        #     }
+        #
+        data = self.safe_dict(response, 'data', {})
+        return self.parse_deposit_withdraw_fee(data, currency)
 
-    def parse_deposit_withdraw_fees(self, response, codes=None, currencyIdKey=None):
-        depositWithdrawFees = {}
-        codes = self.market_codes(codes)
-        data = self.safe_value(response, 'data')
-        currencyIds = list(data.keys())
-        for i in range(0, len(currencyIds)):
-            entry = currencyIds[i]
-            splitEntry = entry.split('-')
-            feeInfo = data[currencyIds[i]]
-            currencyId = self.safe_string(feeInfo, 'asset')
-            currency = self.safe_currency(currencyId)
-            code = self.safe_string(currency, 'code')
-            if (codes is None) or (self.in_array(code, codes)):
-                depositWithdrawFee = self.safe_value(depositWithdrawFees, code)
-                if depositWithdrawFee is None:
-                    depositWithdrawFees[code] = self.deposit_withdraw_fee({})
-                depositWithdrawFees[code]['info'][entry] = feeInfo
-                networkId = self.safe_string(splitEntry, 1)
-                withdrawFee = self.safe_value(feeInfo, 'withdraw_tx_fee')
-                withdrawResult = {
-                    'fee': withdrawFee,
-                    'percentage': False if (withdrawFee is not None) else None,
-                }
-                depositResult = {
-                    'fee': None,
-                    'percentage': None,
-                }
-                if networkId is not None:
-                    networkCode = self.network_id_to_code(networkId)
-                    depositWithdrawFees[code]['networks'][networkCode] = {
-                        'withdraw': withdrawResult,
-                        'deposit': depositResult,
+    def parse_deposit_withdraw_fee(self, fee, currency: Currency = None):
+        #
+        #     {
+        #         "asset": {
+        #             "ccy": "USDT",
+        #             "deposit_enabled": True,
+        #             "withdraw_enabled": True,
+        #             "inter_transfer_enabled": True,
+        #             "is_st": False
+        #         },
+        #         "chains": [
+        #             {
+        #                 "chain": "TRC20",
+        #                 "min_deposit_amount": "2.4",
+        #                 "min_withdraw_amount": "2.4",
+        #                 "deposit_enabled": True,
+        #                 "withdraw_enabled": True,
+        #                 "deposit_delay_minutes": 0,
+        #                 "safe_confirmations": 10,
+        #                 "irreversible_confirmations": 20,
+        #                 "deflation_rate": "0",
+        #                 "withdrawal_fee": "2.4",
+        #                 "withdrawal_precision": 6,
+        #                 "memo": "",
+        #                 "is_memo_required_for_deposit": False,
+        #                 "explorer_asset_url": "https://tronscan.org/#/token20/TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t"
+        #             },
+        #         ]
+        #     }
+        #
+        result: dict = {
+            'info': fee,
+            'withdraw': {
+                'fee': None,
+                'percentage': None,
+            },
+            'deposit': {
+                'fee': None,
+                'percentage': None,
+            },
+            'networks': {},
+        }
+        chains = self.safe_list(fee, 'chains', [])
+        asset = self.safe_dict(fee, 'asset', {})
+        for i in range(0, len(chains)):
+            entry = chains[i]
+            isWithdrawEnabled = self.safe_bool(entry, 'withdraw_enabled')
+            if isWithdrawEnabled:
+                result['withdraw']['fee'] = self.safe_number(entry, 'withdrawal_fee')
+                result['withdraw']['percentage'] = False
+                networkId = self.safe_string(entry, 'chain')
+                if networkId:
+                    networkCode = self.network_id_to_code(networkId, self.safe_string(asset, 'ccy'))
+                    result['networks'][networkCode] = {
+                        'withdraw': {
+                            'fee': self.safe_number(entry, 'withdrawal_fee'),
+                            'percentage': False,
+                        },
+                        'deposit': {
+                            'fee': None,
+                            'percentage': None,
+                        },
                     }
-                else:
-                    depositWithdrawFees[code]['withdraw'] = withdrawResult
-                    depositWithdrawFees[code]['deposit'] = depositResult
-        depositWithdrawCodes = list(depositWithdrawFees.keys())
-        for i in range(0, len(depositWithdrawCodes)):
-            code = depositWithdrawCodes[i]
-            currency = self.currency(code)
-            depositWithdrawFees[code] = self.assign_default_deposit_withdraw_fees(depositWithdrawFees[code], currency)
-        return depositWithdrawFees
+        return result
 
-    async def fetch_leverages(self, symbols: List[str] = None, params={}) -> Leverages:
+    async def fetch_leverage(self, symbol: str, params={}) -> Leverage:
         """
-        fetch the set leverage for all contract and margin markets
-        :see: https://viabtc.github.io/coinex_api_en_doc/spot/#docsspot002_account007_margin_account_settings
-        :param str[] [symbols]: a list of unified market symbols
+        fetch the set leverage for a market
+        :see: https://docs.coinex.com/api/v2/assets/loan-flat/http/list-margin-interest-limit
+        :param str symbol: unified market symbol
         :param dict [params]: extra parameters specific to the exchange API endpoint
-        :returns dict: a list of `leverage structures <https://docs.ccxt.com/#/?id=leverage-structure>`
+        :param str params['code']: unified currency code
+        :returns dict: a `leverage structure <https://docs.ccxt.com/#/?id=leverage-structure>`
         """
         await self.load_markets()
-        symbols = self.market_symbols(symbols)
-        market = None
-        if symbols is not None:
-            symbol = self.safe_value(symbols, 0)
-            market = self.market(symbol)
-        marketType = None
-        marketType, params = self.handle_market_type_and_params('fetchLeverages', market, params)
-        if marketType != 'spot':
-            raise NotSupported(self.id + ' fetchLeverages() supports spot margin markets only')
-        response = await self.v1PrivateGetMarginConfig(params)
+        code = self.safe_string(params, 'code')
+        if code is None:
+            raise ArgumentsRequired(self.id + ' fetchLeverage() requires a code parameter')
+        params = self.omit(params, 'code')
+        currency = self.currency(code)
+        market = self.market(symbol)
+        request: dict = {
+            'market': market['id'],
+            'ccy': currency['id'],
+        }
+        response = await self.v2PrivateGetAssetsMarginInterestLimit(self.extend(request, params))
         #
         #     {
         #         "code": 0,
-        #         "data": [
-        #             {
-        #                 "market": "BTCUSDT",
-        #                 "leverage": 10,
-        #                 "BTC": {
-        #                     "min_amount": "0.0008",
-        #                     "max_amount": "200",
-        #                     "day_rate": "0.0015"
-        #                 },
-        #                 "USDT": {
-        #                     "min_amount": "50",
-        #                     "max_amount": "500000",
-        #                     "day_rate": "0.001"
-        #                 }
-        #             },
-        #         ],
-        #         "message": "Success"
+        #         "data": {
+        #             "market": "BTCUSDT",
+        #             "ccy": "USDT",
+        #             "leverage": 10,
+        #             "min_amount": "50",
+        #             "max_amount": "500000",
+        #             "daily_interest_rate": "0.001"
+        #         },
+        #         "message": "OK"
         #     }
         #
-        leverages = self.safe_list(response, 'data', [])
-        return self.parse_leverages(leverages, symbols, 'market', marketType)
+        data = self.safe_dict(response, 'data', {})
+        return self.parse_leverage(data, market)
 
     def parse_leverage(self, leverage: dict, market: Market = None) -> Leverage:
+        #
+        #     {
+        #         "market": "BTCUSDT",
+        #         "ccy": "USDT",
+        #         "leverage": 10,
+        #         "min_amount": "50",
+        #         "max_amount": "500000",
+        #         "daily_interest_rate": "0.001"
+        #     }
+        #
         marketId = self.safe_string(leverage, 'market')
         leverageValue = self.safe_integer(leverage, 'leverage')
         return {
             'info': leverage,
             'symbol': self.safe_symbol(marketId, market, None, 'spot'),
-            'marginMode': None,
+            'marginMode': 'isolated',
             'longLeverage': leverageValue,
             'shortLeverage': leverageValue,
         }
@@ -5239,7 +5272,7 @@ class coinex(Exchange, ImplicitAPI):
         """
         await self.load_markets()
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'market_type': 'FUTURES',
             'market': market['id'],
         }
@@ -5442,7 +5475,7 @@ class coinex(Exchange, ImplicitAPI):
         if positionId is None:
             raise ArgumentsRequired(self.id + ' fetchMarginAdjustmentHistory() requires a positionId parameter')
         market = self.market(symbol)
-        request = {
+        request: dict = {
             'market': market['id'],
             'market_type': 'FUTURES',
             'position_id': positionId,