ccxt 4.4.80__py2.py3-none-any.whl → 4.4.85__py2.py3-none-any.whl

ccxt/__init__.py

@@ -22,7 +22,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.4.80'
+__version__ = '4.4.85'
 
 # ----------------------------------------------------------------------------
 
@@ -108,7 +108,6 @@ from ccxt.bitso import bitso                                          # noqa: F4
 from ccxt.bitstamp import bitstamp                                    # noqa: F401
 from ccxt.bitteam import bitteam                                      # noqa: F401
 from ccxt.bitvavo import bitvavo                                      # noqa: F401
-from ccxt.bl3p import bl3p                                            # noqa: F401
 from ccxt.blockchaincom import blockchaincom                          # noqa: F401
 from ccxt.blofin import blofin                                        # noqa: F401
 from ccxt.btcalpha import btcalpha                                    # noqa: F401
@@ -150,7 +149,6 @@ from ccxt.htx import htx                                              # noqa: F4
 from ccxt.huobi import huobi                                          # noqa: F401
 from ccxt.huobijp import huobijp                                      # noqa: F401
 from ccxt.hyperliquid import hyperliquid                              # noqa: F401
-from ccxt.idex import idex                                            # noqa: F401
 from ccxt.independentreserve import independentreserve                # noqa: F401
 from ccxt.indodax import indodax                                      # noqa: F401
 from ccxt.kraken import kraken                                        # noqa: F401
@@ -217,7 +215,6 @@ exchanges = [
     'bitstamp',
     'bitteam',
     'bitvavo',
-    'bl3p',
     'blockchaincom',
     'blofin',
     'btcalpha',
@@ -259,7 +256,6 @@ exchanges = [
     'huobi',
     'huobijp',
     'hyperliquid',
-    'idex',
     'independentreserve',
     'indodax',
     'kraken',

ccxt/abstract/blofin.py

@@ -20,10 +20,14 @@ class ImplicitAPI:
     private_get_account_positions = privateGetAccountPositions = Entry('account/positions', 'private', 'GET', {'cost': 1})
     private_get_account_leverage_info = privateGetAccountLeverageInfo = Entry('account/leverage-info', 'private', 'GET', {'cost': 1})
     private_get_account_margin_mode = privateGetAccountMarginMode = Entry('account/margin-mode', 'private', 'GET', {'cost': 1})
+    private_get_account_position_mode = privateGetAccountPositionMode = Entry('account/position-mode', 'private', 'GET', {'cost': 1})
     private_get_account_batch_leverage_info = privateGetAccountBatchLeverageInfo = Entry('account/batch-leverage-info', 'private', 'GET', {'cost': 1})
     private_get_trade_orders_tpsl_pending = privateGetTradeOrdersTpslPending = Entry('trade/orders-tpsl-pending', 'private', 'GET', {'cost': 1})
+    private_get_trade_orders_algo_pending = privateGetTradeOrdersAlgoPending = Entry('trade/orders-algo-pending', 'private', 'GET', {'cost': 1})
     private_get_trade_orders_history = privateGetTradeOrdersHistory = Entry('trade/orders-history', 'private', 'GET', {'cost': 1})
     private_get_trade_orders_tpsl_history = privateGetTradeOrdersTpslHistory = Entry('trade/orders-tpsl-history', 'private', 'GET', {'cost': 1})
+    private_get_trade_orders_algo_history = privateGetTradeOrdersAlgoHistory = Entry('trade/orders-algo-history', 'private', 'GET', {'cost': 1})
+    private_get_trade_order_price_range = privateGetTradeOrderPriceRange = Entry('trade/order/price-range', 'private', 'GET', {'cost': 1})
     private_get_user_query_apikey = privateGetUserQueryApikey = Entry('user/query-apikey', 'private', 'GET', {'cost': 1})
     private_get_affiliate_basic = privateGetAffiliateBasic = Entry('affiliate/basic', 'private', 'GET', {'cost': 1})
     private_get_copytrading_instruments = privateGetCopytradingInstruments = Entry('copytrading/instruments', 'private', 'GET', {'cost': 1})
@@ -38,8 +42,12 @@ class ImplicitAPI:
     private_get_copytrading_trade_position_history_by_order = privateGetCopytradingTradePositionHistoryByOrder = Entry('copytrading/trade/position-history-by-order', 'private', 'GET', {'cost': 1})
     private_get_copytrading_trade_orders_history = privateGetCopytradingTradeOrdersHistory = Entry('copytrading/trade/orders-history', 'private', 'GET', {'cost': 1})
     private_get_copytrading_trade_pending_tpsl_by_order = privateGetCopytradingTradePendingTpslByOrder = Entry('copytrading/trade/pending-tpsl-by-order', 'private', 'GET', {'cost': 1})
+    private_post_account_set_margin_mode = privatePostAccountSetMarginMode = Entry('account/set-margin-mode', 'private', 'POST', {'cost': 1})
+    private_post_account_set_position_mode = privatePostAccountSetPositionMode = Entry('account/set-position-mode', 'private', 'POST', {'cost': 1})
     private_post_trade_order = privatePostTradeOrder = Entry('trade/order', 'private', 'POST', {'cost': 1})
+    private_post_trade_order_algo = privatePostTradeOrderAlgo = Entry('trade/order-algo', 'private', 'POST', {'cost': 1})
     private_post_trade_cancel_order = privatePostTradeCancelOrder = Entry('trade/cancel-order', 'private', 'POST', {'cost': 1})
+    private_post_trade_cancel_algo = privatePostTradeCancelAlgo = Entry('trade/cancel-algo', 'private', 'POST', {'cost': 1})
     private_post_account_set_leverage = privatePostAccountSetLeverage = Entry('account/set-leverage', 'private', 'POST', {'cost': 1})
     private_post_trade_batch_orders = privatePostTradeBatchOrders = Entry('trade/batch-orders', 'private', 'POST', {'cost': 1})
     private_post_trade_order_tpsl = privatePostTradeOrderTpsl = Entry('trade/order-tpsl', 'private', 'POST', {'cost': 1})

ccxt/abstract/btcbox.py

@@ -12,3 +12,4 @@ class ImplicitAPI:
     private_post_trade_list = privatePostTradeList = Entry('trade_list', 'private', 'POST', {})
     private_post_trade_view = privatePostTradeView = Entry('trade_view', 'private', 'POST', {})
     private_post_wallet = privatePostWallet = Entry('wallet', 'private', 'POST', {})
+    webapi_get_ajax_coin_coininfo = webApiGetAjaxCoinCoinInfo = Entry('ajax/coin/coinInfo', 'webApi', 'GET', {})

ccxt/apex.py

@@ -498,11 +498,6 @@ class apex(Exchange, ImplicitAPI):
             code = self.safe_currency_code(currencyId)
             name = self.safe_string(currency, 'displayName')
             networks: dict = {}
-            minPrecision = None
-            minWithdrawFeeString = None
-            minWithdrawString = None
-            deposit = False
-            withdraw = False
             for j in range(0, len(chains)):
                 chain = chains[j]
                 tokens = self.safe_list(chain, 'tokens', [])
@@ -512,53 +507,48 @@ class apex(Exchange, ImplicitAPI):
                     if tokenName == currencyId:
                         networkId = self.safe_string(chain, 'chainId')
                         networkCode = self.network_id_to_code(networkId)
-                        precision = self.parse_number(self.parse_precision(self.safe_string(currency, 'decimals')))
-                        minPrecision = precision if (minPrecision is None) else min(minPrecision, precision)
-                        depositAllowed = not self.safe_bool(chain, 'stopDeposit')
-                        deposit = depositAllowed if (depositAllowed) else deposit
-                        withdrawAllowed = self.safe_bool(token, 'withdrawEnable')
-                        withdraw = withdrawAllowed if (withdrawAllowed) else withdraw
-                        minWithdrawFeeString = self.safe_string(token, 'minFee')
-                        minWithdrawString = self.safe_string(token, 'minWithdraw')
-                        minNetworkDepositString = self.safe_string(chain, 'depositMin')
                         networks[networkCode] = {
                             'info': chain,
                             'id': networkId,
                             'network': networkCode,
-                            'active': depositAllowed and withdrawAllowed,
-                            'deposit': depositAllowed,
-                            'withdraw': withdrawAllowed,
-                            'fee': self.parse_number(minWithdrawFeeString),
-                            'precision': precision,
+                            'active': None,
+                            'deposit': not self.safe_bool(chain, 'depositDisable'),
+                            'withdraw': self.safe_bool(token, 'withdrawEnable'),
+                            'fee': self.safe_number(token, 'minFee'),
+                            'precision': self.parse_number(self.parse_precision(self.safe_string(token, 'decimals'))),
                             'limits': {
                                 'withdraw': {
-                                    'min': self.parse_number(minWithdrawString),
+                                    'min': self.safe_number(token, 'minWithdraw'),
                                     'max': None,
                                 },
                                 'deposit': {
-                                    'min': self.parse_number(minNetworkDepositString),
+                                    'min': self.safe_number(chain, 'minDeposit'),
                                     'max': None,
                                 },
                             },
                         }
-            result[code] = {
+            networkKeys = list(networks.keys())
+            networksLength = len(networkKeys)
+            emptyChains = networksLength == 0  # non-functional coins
+            valueForEmpty = False if emptyChains else None
+            result[code] = self.safe_currency_structure({
                 'info': currency,
                 'code': code,
                 'id': currencyId,
                 'type': 'crypto',
                 'name': name,
-                'active': deposit and withdraw,
-                'deposit': deposit,
-                'withdraw': withdraw,
-                'fee': self.parse_number(minWithdrawFeeString),
-                'precision': minPrecision,
+                'active': None,
+                'deposit': valueForEmpty,
+                'withdraw': valueForEmpty,
+                'fee': None,
+                'precision': None,
                 'limits': {
                     'amount': {
                         'min': None,
                         'max': None,
                     },
                     'withdraw': {
-                        'min': self.parse_number(minWithdrawString),
+                        'min': None,
                         'max': None,
                     },
                     'deposit': {
@@ -567,7 +557,7 @@ class apex(Exchange, ImplicitAPI):
                     },
                 },
                 'networks': networks,
-            }
+            })
         return result
 
     def fetch_markets(self, params={}) -> List[Market]:
@@ -1087,9 +1077,10 @@ class apex(Exchange, ImplicitAPI):
         for i in range(0, len(resultList)):
             entry = resultList[i]
             timestamp = self.safe_integer(entry, 'fundingTimestamp')
+            marketId = self.safe_string(entry, 'symbol')
             rates.append({
                 'info': entry,
-                'symbol': self.safe_string(entry, 'symbol'),
+                'symbol': self.safe_symbol(marketId, market),
                 'fundingRate': self.safe_number(entry, 'rate'),
                 'timestamp': timestamp,
                 'datetime': self.iso8601(timestamp),

ccxt/ascendex.py

@@ -610,7 +610,7 @@ class ascendex(Exchange, ImplicitAPI):
                         'max': None,
                     },
                 },
-                'networks': {},
+                'networks': {},  # todo
             }
         return result
 

ccxt/async_support/__init__.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.4.80'
+__version__ = '4.4.85'
 
 # -----------------------------------------------------------------------------
 
@@ -88,7 +88,6 @@ from ccxt.async_support.bitso import bitso
 from ccxt.async_support.bitstamp import bitstamp                                # noqa: F401
 from ccxt.async_support.bitteam import bitteam                                  # noqa: F401
 from ccxt.async_support.bitvavo import bitvavo                                  # noqa: F401
-from ccxt.async_support.bl3p import bl3p                                        # noqa: F401
 from ccxt.async_support.blockchaincom import blockchaincom                      # noqa: F401
 from ccxt.async_support.blofin import blofin                                    # noqa: F401
 from ccxt.async_support.btcalpha import btcalpha                                # noqa: F401
@@ -130,7 +129,6 @@ from ccxt.async_support.htx import htx
 from ccxt.async_support.huobi import huobi                                      # noqa: F401
 from ccxt.async_support.huobijp import huobijp                                  # noqa: F401
 from ccxt.async_support.hyperliquid import hyperliquid                          # noqa: F401
-from ccxt.async_support.idex import idex                                        # noqa: F401
 from ccxt.async_support.independentreserve import independentreserve            # noqa: F401
 from ccxt.async_support.indodax import indodax                                  # noqa: F401
 from ccxt.async_support.kraken import kraken                                    # noqa: F401
@@ -197,7 +195,6 @@ exchanges = [
     'bitstamp',
     'bitteam',
     'bitvavo',
-    'bl3p',
     'blockchaincom',
     'blofin',
     'btcalpha',
@@ -239,7 +236,6 @@ exchanges = [
     'huobi',
     'huobijp',
     'hyperliquid',
-    'idex',
     'independentreserve',
     'indodax',
     'kraken',

ccxt/async_support/apex.py

@@ -498,11 +498,6 @@ class apex(Exchange, ImplicitAPI):
             code = self.safe_currency_code(currencyId)
             name = self.safe_string(currency, 'displayName')
             networks: dict = {}
-            minPrecision = None
-            minWithdrawFeeString = None
-            minWithdrawString = None
-            deposit = False
-            withdraw = False
             for j in range(0, len(chains)):
                 chain = chains[j]
                 tokens = self.safe_list(chain, 'tokens', [])
@@ -512,53 +507,48 @@ class apex(Exchange, ImplicitAPI):
                     if tokenName == currencyId:
                         networkId = self.safe_string(chain, 'chainId')
                         networkCode = self.network_id_to_code(networkId)
-                        precision = self.parse_number(self.parse_precision(self.safe_string(currency, 'decimals')))
-                        minPrecision = precision if (minPrecision is None) else min(minPrecision, precision)
-                        depositAllowed = not self.safe_bool(chain, 'stopDeposit')
-                        deposit = depositAllowed if (depositAllowed) else deposit
-                        withdrawAllowed = self.safe_bool(token, 'withdrawEnable')
-                        withdraw = withdrawAllowed if (withdrawAllowed) else withdraw
-                        minWithdrawFeeString = self.safe_string(token, 'minFee')
-                        minWithdrawString = self.safe_string(token, 'minWithdraw')
-                        minNetworkDepositString = self.safe_string(chain, 'depositMin')
                         networks[networkCode] = {
                             'info': chain,
                             'id': networkId,
                             'network': networkCode,
-                            'active': depositAllowed and withdrawAllowed,
-                            'deposit': depositAllowed,
-                            'withdraw': withdrawAllowed,
-                            'fee': self.parse_number(minWithdrawFeeString),
-                            'precision': precision,
+                            'active': None,
+                            'deposit': not self.safe_bool(chain, 'depositDisable'),
+                            'withdraw': self.safe_bool(token, 'withdrawEnable'),
+                            'fee': self.safe_number(token, 'minFee'),
+                            'precision': self.parse_number(self.parse_precision(self.safe_string(token, 'decimals'))),
                             'limits': {
                                 'withdraw': {
-                                    'min': self.parse_number(minWithdrawString),
+                                    'min': self.safe_number(token, 'minWithdraw'),
                                     'max': None,
                                 },
                                 'deposit': {
-                                    'min': self.parse_number(minNetworkDepositString),
+                                    'min': self.safe_number(chain, 'minDeposit'),
                                     'max': None,
                                 },
                             },
                         }
-            result[code] = {
+            networkKeys = list(networks.keys())
+            networksLength = len(networkKeys)
+            emptyChains = networksLength == 0  # non-functional coins
+            valueForEmpty = False if emptyChains else None
+            result[code] = self.safe_currency_structure({
                 'info': currency,
                 'code': code,
                 'id': currencyId,
                 'type': 'crypto',
                 'name': name,
-                'active': deposit and withdraw,
-                'deposit': deposit,
-                'withdraw': withdraw,
-                'fee': self.parse_number(minWithdrawFeeString),
-                'precision': minPrecision,
+                'active': None,
+                'deposit': valueForEmpty,
+                'withdraw': valueForEmpty,
+                'fee': None,
+                'precision': None,
                 'limits': {
                     'amount': {
                         'min': None,
                         'max': None,
                     },
                     'withdraw': {
-                        'min': self.parse_number(minWithdrawString),
+                        'min': None,
                         'max': None,
                     },
                     'deposit': {
@@ -567,7 +557,7 @@ class apex(Exchange, ImplicitAPI):
                     },
                 },
                 'networks': networks,
-            }
+            })
         return result
 
     async def fetch_markets(self, params={}) -> List[Market]:
@@ -1087,9 +1077,10 @@ class apex(Exchange, ImplicitAPI):
         for i in range(0, len(resultList)):
             entry = resultList[i]
             timestamp = self.safe_integer(entry, 'fundingTimestamp')
+            marketId = self.safe_string(entry, 'symbol')
             rates.append({
                 'info': entry,
-                'symbol': self.safe_string(entry, 'symbol'),
+                'symbol': self.safe_symbol(marketId, market),
                 'fundingRate': self.safe_number(entry, 'rate'),
                 'timestamp': timestamp,
                 'datetime': self.iso8601(timestamp),

ccxt/async_support/ascendex.py

@@ -611,7 +611,7 @@ class ascendex(Exchange, ImplicitAPI):
                         'max': None,
                     },
                 },
-                'networks': {},
+                'networks': {},  # todo
             }
         return result
 

ccxt/async_support/base/exchange.py

@@ -2,7 +2,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.4.80'
+__version__ = '4.4.85'
 
 # -----------------------------------------------------------------------------
 
@@ -34,7 +34,7 @@ from ccxt.base.exchange import Exchange as BaseExchange, ArgumentsRequired
 # -----------------------------------------------------------------------------
 
 from ccxt.async_support.base.ws.functions import inflate, inflate64, gunzip
-from ccxt.async_support.base.ws.fast_client import FastClient
+from ccxt.async_support.base.ws.aiohttp_client import AiohttpClient
 from ccxt.async_support.base.ws.future import Future
 from ccxt.async_support.base.ws.order_book import OrderBook, IndexedOrderBook, CountedOrderBook
 
@@ -279,7 +279,28 @@ class Exchange(BaseExchange):
         markets = await self.fetch_markets(params)
         return self.set_markets(markets, currencies)
 
+
     async def load_markets(self, reload=False, params={}):
+        """
+        Loads and prepares the markets for trading.
+
+        Args:
+            reload (bool): If True, the markets will be reloaded from the exchange.
+            params (dict): Additional exchange-specific parameters for the request.
+
+        Returns:
+            dict: A dictionary of markets.
+
+        Raises:
+            Exception: If the markets cannot be loaded or prepared.
+
+        Notes:
+            This method is asynchronous.
+            It ensures that the markets are only loaded once, even if called multiple times.
+            If the markets are already loaded and `reload` is False or not provided, it returns the existing markets.
+            If a reload is in progress, it waits for completion before returning.
+            If an error occurs during loading or preparation, an exception is raised.
+        """
         if (reload and not self.reloading_markets) or not self.markets_loading:
             self.reloading_markets = True
             coroutine = self.load_markets_helper(reload, params)
@@ -387,7 +408,9 @@ class Exchange(BaseExchange):
                 'throttle': Throttler(self.tokenBucket, self.asyncio_loop),
                 'asyncio_loop': self.asyncio_loop,
             }, ws_options)
-            self.clients[url] = FastClient(url, on_message, on_error, on_close, on_connected, options)
+            # we use aiohttp instead of fastClient now because of this
+            # https://github.com/ccxt/ccxt/pull/25995
+            self.clients[url] = AiohttpClient(url, on_message, on_error, on_close, on_connected, options)
             self.clients[url].proxy = self.get_ws_proxy()
         return self.clients[url]
 

ccxt/async_support/base/ws/cache.py

@@ -1,5 +1,7 @@
 import collections
+import logging
 
+logger = logging.getLogger(__name__)
 
 class Delegate:
     def __init__(self, name, delegated):
@@ -151,7 +153,10 @@ class ArrayCacheBySymbolById(ArrayCache):
         if len(self._deque) == self._deque.maxlen:
             delete_item = self._deque.popleft()
             self._index.popleft()
-            del self.hashmap[delete_item['symbol']][delete_item['id']]
+            try:
+                del self.hashmap[delete_item['symbol']][delete_item['id']]
+            except Exception as e:
+                logger.error(f"Error deleting item from hashmap: {delete_item}. Error:{e}")
         self._deque.append(item)
         self._index.append(item['id'])
         if self._clear_all_updates:

ccxt/async_support/bigone.py

@@ -6,7 +6,7 @@
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.bigone import ImplicitAPI
 import asyncio
-from ccxt.base.types import Any, Balances, Bool, Currencies, Currency, DepositAddress, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction, TransferEntry
+from ccxt.base.types import Any, Balances, Currencies, Currency, DepositAddress, Int, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
@@ -510,19 +510,15 @@ class bigone(Exchange, ImplicitAPI):
             id = self.safe_string(currency, 'symbol')
             code = self.safe_currency_code(id)
             name = self.safe_string(currency, 'name')
-            type = 'fiat' if self.safe_bool(currency, 'is_fiat') else 'crypto'
             networks: dict = {}
             chains = self.safe_list(currency, 'binding_gateways', [])
             currencyMaxPrecision = self.parse_precision(self.safe_string_2(currency, 'withdrawal_scale', 'scale'))
-            currencyDepositEnabled: Bool = None
-            currencyWithdrawEnabled: Bool = None
             for j in range(0, len(chains)):
                 chain = chains[j]
                 networkId = self.safe_string(chain, 'gateway_name')
                 networkCode = self.network_id_to_code(networkId)
                 deposit = self.safe_bool(chain, 'is_deposit_enabled')
                 withdraw = self.safe_bool(chain, 'is_withdrawal_enabled')
-                isActive = (deposit and withdraw)
                 minDepositAmount = self.safe_string(chain, 'min_deposit_amount')
                 minWithdrawalAmount = self.safe_string(chain, 'min_withdrawal_amount')
                 withdrawalFee = self.safe_string(chain, 'withdrawal_fee')
@@ -533,7 +529,7 @@ class bigone(Exchange, ImplicitAPI):
                     'margin': None,
                     'deposit': deposit,
                     'withdraw': withdraw,
-                    'active': isActive,
+                    'active': None,
                     'fee': self.parse_number(withdrawalFee),
                     'precision': self.parse_number(precision),
                     'limits': {
@@ -548,19 +544,26 @@ class bigone(Exchange, ImplicitAPI):
                     },
                     'info': chain,
                 }
-                # fill global values
-                currencyDepositEnabled = (currencyDepositEnabled is None) or deposit if deposit else currencyDepositEnabled
-                currencyWithdrawEnabled = (currencyWithdrawEnabled is None) or withdraw if withdraw else currencyWithdrawEnabled
-                currencyMaxPrecision = (currencyMaxPrecision is None) or precision if Precise.string_gt(currencyMaxPrecision, precision) else currencyMaxPrecision
-            result[code] = {
+            chainLength = len(chains)
+            type: Str = None
+            if self.safe_bool(currency, 'is_fiat'):
+                type = 'fiat'
+            elif chainLength == 0:
+                if self.is_leveraged_currency(id):
+                    type = 'leveraged'
+                else:
+                    type = 'other'
+            else:
+                type = 'crypto'
+            result[code] = self.safe_currency_structure({
                 'id': id,
                 'code': code,
                 'info': currency,
                 'name': name,
                 'type': type,
                 'active': None,
-                'deposit': currencyDepositEnabled,
-                'withdraw': currencyWithdrawEnabled,
+                'deposit': None,
+                'withdraw': None,
                 'fee': None,
                 'precision': self.parse_number(currencyMaxPrecision),
                 'limits': {
@@ -574,7 +577,7 @@ class bigone(Exchange, ImplicitAPI):
                     },
                 },
                 'networks': networks,
-            }
+            })
         return result
 
     async def fetch_markets(self, params={}) -> List[Market]:

ccxt/async_support/bingx.py

@@ -767,56 +767,41 @@ class bingx(Exchange, ImplicitAPI):
             name = self.safe_string(entry, 'name')
             networkList = self.safe_list(entry, 'networkList')
             networks: dict = {}
-            fee = None
-            depositEnabled = False
-            withdrawEnabled = False
-            defaultLimits: dict = {}
             for j in range(0, len(networkList)):
                 rawNetwork = networkList[j]
                 network = self.safe_string(rawNetwork, 'network')
                 networkCode = self.network_id_to_code(network)
-                isDefault = self.safe_bool(rawNetwork, 'isDefault')
-                networkDepositEnabled = self.safe_bool(rawNetwork, 'depositEnable')
-                if networkDepositEnabled:
-                    depositEnabled = True
-                networkWithdrawEnabled = self.safe_bool(rawNetwork, 'withdrawEnable')
-                if networkWithdrawEnabled:
-                    withdrawEnabled = True
                 limits: dict = {
                     'withdraw': {
                         'min': self.safe_number(rawNetwork, 'withdrawMin'),
                         'max': self.safe_number(rawNetwork, 'withdrawMax'),
                     },
                 }
-                fee = self.safe_number(rawNetwork, 'withdrawFee')
-                if isDefault:
-                    defaultLimits = limits
-                precision = self.safe_number(rawNetwork, 'withdrawPrecision')
-                networkActive = networkDepositEnabled or networkWithdrawEnabled
+                precision = self.parse_number(self.parse_precision(self.safe_string(rawNetwork, 'withdrawPrecision')))
                 networks[networkCode] = {
                     'info': rawNetwork,
                     'id': network,
                     'network': networkCode,
-                    'fee': fee,
-                    'active': networkActive,
-                    'deposit': networkDepositEnabled,
-                    'withdraw': networkWithdrawEnabled,
+                    'fee': self.safe_number(rawNetwork, 'withdrawFee'),
+                    'active': None,
+                    'deposit': self.safe_bool(rawNetwork, 'depositEnable'),
+                    'withdraw': self.safe_bool(rawNetwork, 'withdrawEnable'),
                     'precision': precision,
                     'limits': limits,
                 }
-            active = depositEnabled or withdrawEnabled
             result[code] = self.safe_currency_structure({
                 'info': entry,
                 'code': code,
                 'id': currencyId,
                 'precision': None,
                 'name': name,
-                'active': active,
-                'deposit': depositEnabled,
-                'withdraw': withdrawEnabled,
+                'active': None,
+                'deposit': None,
+                'withdraw': None,
                 'networks': networks,
-                'fee': fee,
-                'limits': defaultLimits,
+                'fee': None,
+                'limits': None,
+                'type': 'crypto',  # only cryptos now
             })
         return result
 
@@ -5536,18 +5521,14 @@ class bingx(Exchange, ImplicitAPI):
         :param str address: the address to withdraw to
         :param str [tag]:
         :param dict [params]: extra parameters specific to the exchange API endpoint
-        :param int [params.walletType]: 1 fund account, 2 standard account, 3 perpetual account
+        :param int [params.walletType]: 1 fund account, 2 standard account, 3 perpetual account, 15 spot account
         :returns dict: a `transaction structure <https://docs.ccxt.com/#/?id=transaction-structure>`
         """
         tag, params = self.handle_withdraw_tag_and_params(tag, params)
         self.check_address(address)
         await self.load_markets()
         currency = self.currency(code)
-        walletType = self.safe_integer(params, 'walletType')
-        if walletType is None:
-            walletType = 1
-        if not self.in_array(walletType, [1, 2, 3]):
-            raise BadRequest(self.id + ' withdraw() requires either 1 fund account, 2 standard futures account, 3 perpetual account for walletType')
+        walletType = self.safe_integer(params, 'walletType', 1)
         request: dict = {
             'coin': currency['id'],
             'address': address,