ccxt 4.4.94__py2.py3-none-any.whl → 4.4.95__py2.py3-none-any.whl

ccxt/__init__.py

@@ -22,7 +22,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.4.94'
+__version__ = '4.4.95'
 
 # ----------------------------------------------------------------------------
 

ccxt/abstract/bingx.py

@@ -153,6 +153,9 @@ class ImplicitAPI:
     copytrading_v1_private_post_swap_trace_settpsl = copyTradingV1PrivatePostSwapTraceSetTPSL = Entry('swap/trace/setTPSL', ['copyTrading', 'v1', 'private'], 'POST', {'cost': 2})
     copytrading_v1_private_post_spot_trader_sellorder = copyTradingV1PrivatePostSpotTraderSellOrder = Entry('spot/trader/sellOrder', ['copyTrading', 'v1', 'private'], 'POST', {'cost': 10})
     api_v3_private_get_asset_transfer = apiV3PrivateGetAssetTransfer = Entry('asset/transfer', ['api', 'v3', 'private'], 'GET', {'cost': 1})
+    api_v3_private_get_asset_transferrecord = apiV3PrivateGetAssetTransferRecord = Entry('asset/transferRecord', ['api', 'v3', 'private'], 'GET', {'cost': 5})
     api_v3_private_get_capital_deposit_hisrec = apiV3PrivateGetCapitalDepositHisrec = Entry('capital/deposit/hisrec', ['api', 'v3', 'private'], 'GET', {'cost': 1})
     api_v3_private_get_capital_withdraw_history = apiV3PrivateGetCapitalWithdrawHistory = Entry('capital/withdraw/history', ['api', 'v3', 'private'], 'GET', {'cost': 1})
     api_v3_private_post_post_asset_transfer = apiV3PrivatePostPostAssetTransfer = Entry('post/asset/transfer', ['api', 'v3', 'private'], 'POST', {'cost': 1})
+    api_asset_v1_private_post_transfer = apiAssetV1PrivatePostTransfer = Entry('transfer', ['api', 'asset', 'v1', 'private'], 'POST', {'cost': 5})
+    api_asset_v1_public_get_transfer_supportcoins = apiAssetV1PublicGetTransferSupportCoins = Entry('transfer/supportCoins', ['api', 'asset', 'v1', 'public'], 'GET', {'cost': 5})

ccxt/abstract/hyperliquid.py

@@ -2,5 +2,5 @@ from ccxt.base.types import Entry
 
 
 class ImplicitAPI:
-    public_post_info = publicPostInfo = Entry('info', 'public', 'POST', {'cost': 20, 'byType': {'l2Book': 2, 'allMids': 2, 'clearinghouseState': 2, 'orderStatus': 2, 'spotClearinghouseState': 2, 'exchangeStatus': 2}})
+    public_post_info = publicPostInfo = Entry('info', 'public', 'POST', {'cost': 20, 'byType': {'l2Book': 2, 'allMids': 2, 'clearinghouseState': 2, 'orderStatus': 2, 'spotClearinghouseState': 2, 'exchangeStatus': 2, 'candleSnapshot': 3}})
     private_post_exchange = privatePostExchange = Entry('exchange', 'private', 'POST', {'cost': 1})

ccxt/abstract/woo.py

@@ -60,26 +60,81 @@ class ImplicitAPI:
     v1_private_delete_orders = v1PrivateDeleteOrders = Entry('orders', ['v1', 'private'], 'DELETE', {'cost': 1})
     v1_private_delete_asset_withdraw = v1PrivateDeleteAssetWithdraw = Entry('asset/withdraw', ['v1', 'private'], 'DELETE', {'cost': 120})
     v2_private_get_client_holding = v2PrivateGetClientHolding = Entry('client/holding', ['v2', 'private'], 'GET', {'cost': 1})
-    v3_public_get_insurancefund = v3PublicGetInsuranceFund = Entry('insuranceFund', ['v3', 'public'], 'GET', {'cost': 3})
+    v3_public_get_systeminfo = v3PublicGetSystemInfo = Entry('systemInfo', ['v3', 'public'], 'GET', {'cost': 1})
+    v3_public_get_instruments = v3PublicGetInstruments = Entry('instruments', ['v3', 'public'], 'GET', {'cost': 1})
+    v3_public_get_token = v3PublicGetToken = Entry('token', ['v3', 'public'], 'GET', {'cost': 1})
+    v3_public_get_tokennetwork = v3PublicGetTokenNetwork = Entry('tokenNetwork', ['v3', 'public'], 'GET', {'cost': 1})
+    v3_public_get_tokeninfo = v3PublicGetTokenInfo = Entry('tokenInfo', ['v3', 'public'], 'GET', {'cost': 1})
+    v3_public_get_markettrades = v3PublicGetMarketTrades = Entry('marketTrades', ['v3', 'public'], 'GET', {'cost': 1})
+    v3_public_get_markettradeshistory = v3PublicGetMarketTradesHistory = Entry('marketTradesHistory', ['v3', 'public'], 'GET', {'cost': 1})
+    v3_public_get_orderbook = v3PublicGetOrderbook = Entry('orderbook', ['v3', 'public'], 'GET', {'cost': 1})
+    v3_public_get_kline = v3PublicGetKline = Entry('kline', ['v3', 'public'], 'GET', {'cost': 1})
+    v3_public_get_klinehistory = v3PublicGetKlineHistory = Entry('klineHistory', ['v3', 'public'], 'GET', {'cost': 1})
+    v3_public_get_futures = v3PublicGetFutures = Entry('futures', ['v3', 'public'], 'GET', {'cost': 1})
+    v3_public_get_fundingrate = v3PublicGetFundingRate = Entry('fundingRate', ['v3', 'public'], 'GET', {'cost': 1})
+    v3_public_get_fundingratehistory = v3PublicGetFundingRateHistory = Entry('fundingRateHistory', ['v3', 'public'], 'GET', {'cost': 1})
+    v3_public_get_insurancefund = v3PublicGetInsuranceFund = Entry('insuranceFund', ['v3', 'public'], 'GET', {'cost': 1})
+    v3_private_get_trade_order = v3PrivateGetTradeOrder = Entry('trade/order', ['v3', 'private'], 'GET', {'cost': 2})
+    v3_private_get_trade_orders = v3PrivateGetTradeOrders = Entry('trade/orders', ['v3', 'private'], 'GET', {'cost': 1})
+    v3_private_get_trade_algoorder = v3PrivateGetTradeAlgoOrder = Entry('trade/algoOrder', ['v3', 'private'], 'GET', {'cost': 1})
+    v3_private_get_trade_algoorders = v3PrivateGetTradeAlgoOrders = Entry('trade/algoOrders', ['v3', 'private'], 'GET', {'cost': 1})
+    v3_private_get_trade_transaction = v3PrivateGetTradeTransaction = Entry('trade/transaction', ['v3', 'private'], 'GET', {'cost': 1})
+    v3_private_get_trade_transactionhistory = v3PrivateGetTradeTransactionHistory = Entry('trade/transactionHistory', ['v3', 'private'], 'GET', {'cost': 5})
+    v3_private_get_trade_tradingfee = v3PrivateGetTradeTradingFee = Entry('trade/tradingFee', ['v3', 'private'], 'GET', {'cost': 5})
+    v3_private_get_account_info = v3PrivateGetAccountInfo = Entry('account/info', ['v3', 'private'], 'GET', {'cost': 60})
+    v3_private_get_account_tokenconfig = v3PrivateGetAccountTokenConfig = Entry('account/tokenConfig', ['v3', 'private'], 'GET', {'cost': 1})
+    v3_private_get_account_symbolconfig = v3PrivateGetAccountSymbolConfig = Entry('account/symbolConfig', ['v3', 'private'], 'GET', {'cost': 1})
+    v3_private_get_account_subaccounts_all = v3PrivateGetAccountSubAccountsAll = Entry('account/subAccounts/all', ['v3', 'private'], 'GET', {'cost': 60})
+    v3_private_get_account_referral_summary = v3PrivateGetAccountReferralSummary = Entry('account/referral/summary', ['v3', 'private'], 'GET', {'cost': 60})
+    v3_private_get_account_referral_rewardhistory = v3PrivateGetAccountReferralRewardHistory = Entry('account/referral/rewardHistory', ['v3', 'private'], 'GET', {'cost': 60})
+    v3_private_get_account_credentials = v3PrivateGetAccountCredentials = Entry('account/credentials', ['v3', 'private'], 'GET', {'cost': 60})
+    v3_private_get_asset_balances = v3PrivateGetAssetBalances = Entry('asset/balances', ['v3', 'private'], 'GET', {'cost': 1})
+    v3_private_get_asset_token_history = v3PrivateGetAssetTokenHistory = Entry('asset/token/history', ['v3', 'private'], 'GET', {'cost': 60})
+    v3_private_get_asset_transfer_history = v3PrivateGetAssetTransferHistory = Entry('asset/transfer/history', ['v3', 'private'], 'GET', {'cost': 30})
+    v3_private_get_asset_wallet_history = v3PrivateGetAssetWalletHistory = Entry('asset/wallet/history', ['v3', 'private'], 'GET', {'cost': 60})
+    v3_private_get_asset_wallet_deposit = v3PrivateGetAssetWalletDeposit = Entry('asset/wallet/deposit', ['v3', 'private'], 'GET', {'cost': 60})
+    v3_private_get_asset_staking_yieldhistory = v3PrivateGetAssetStakingYieldHistory = Entry('asset/staking/yieldHistory', ['v3', 'private'], 'GET', {'cost': 60})
+    v3_private_get_futures_positions = v3PrivateGetFuturesPositions = Entry('futures/positions', ['v3', 'private'], 'GET', {'cost': 3.33})
+    v3_private_get_futures_leverage = v3PrivateGetFuturesLeverage = Entry('futures/leverage', ['v3', 'private'], 'GET', {'cost': 60})
+    v3_private_get_futures_defaultmarginmode = v3PrivateGetFuturesDefaultMarginMode = Entry('futures/defaultMarginMode', ['v3', 'private'], 'GET', {'cost': 60})
+    v3_private_get_futures_fundingfee_history = v3PrivateGetFuturesFundingFeeHistory = Entry('futures/fundingFee/history', ['v3', 'private'], 'GET', {'cost': 30})
+    v3_private_get_spotmargin_interestrate = v3PrivateGetSpotMarginInterestRate = Entry('spotMargin/interestRate', ['v3', 'private'], 'GET', {'cost': 60})
+    v3_private_get_spotmargin_interesthistory = v3PrivateGetSpotMarginInterestHistory = Entry('spotMargin/interestHistory', ['v3', 'private'], 'GET', {'cost': 60})
+    v3_private_get_spotmargin_maxmargin = v3PrivateGetSpotMarginMaxMargin = Entry('spotMargin/maxMargin', ['v3', 'private'], 'GET', {'cost': 60})
     v3_private_get_algo_order_oid = v3PrivateGetAlgoOrderOid = Entry('algo/order/{oid}', ['v3', 'private'], 'GET', {'cost': 1})
     v3_private_get_algo_orders = v3PrivateGetAlgoOrders = Entry('algo/orders', ['v3', 'private'], 'GET', {'cost': 1})
     v3_private_get_balances = v3PrivateGetBalances = Entry('balances', ['v3', 'private'], 'GET', {'cost': 1})
-    v3_private_get_accountinfo = v3PrivateGetAccountinfo = Entry('accountinfo', ['v3', 'private'], 'GET', {'cost': 60})
     v3_private_get_positions = v3PrivateGetPositions = Entry('positions', ['v3', 'private'], 'GET', {'cost': 3.33})
     v3_private_get_buypower = v3PrivateGetBuypower = Entry('buypower', ['v3', 'private'], 'GET', {'cost': 1})
-    v3_private_get_referrals = v3PrivateGetReferrals = Entry('referrals', ['v3', 'private'], 'GET', {'cost': 60})
-    v3_private_get_referral_rewards = v3PrivateGetReferralRewards = Entry('referral_rewards', ['v3', 'private'], 'GET', {'cost': 60})
     v3_private_get_convert_exchangeinfo = v3PrivateGetConvertExchangeInfo = Entry('convert/exchangeInfo', ['v3', 'private'], 'GET', {'cost': 1})
     v3_private_get_convert_assetinfo = v3PrivateGetConvertAssetInfo = Entry('convert/assetInfo', ['v3', 'private'], 'GET', {'cost': 1})
     v3_private_get_convert_rfq = v3PrivateGetConvertRfq = Entry('convert/rfq', ['v3', 'private'], 'GET', {'cost': 60})
     v3_private_get_convert_trade = v3PrivateGetConvertTrade = Entry('convert/trade', ['v3', 'private'], 'GET', {'cost': 1})
     v3_private_get_convert_trades = v3PrivateGetConvertTrades = Entry('convert/trades', ['v3', 'private'], 'GET', {'cost': 1})
+    v3_private_post_trade_order = v3PrivatePostTradeOrder = Entry('trade/order', ['v3', 'private'], 'POST', {'cost': 2})
+    v3_private_post_trade_algoorder = v3PrivatePostTradeAlgoOrder = Entry('trade/algoOrder', ['v3', 'private'], 'POST', {'cost': 5})
+    v3_private_post_trade_cancelallafter = v3PrivatePostTradeCancelAllAfter = Entry('trade/cancelAllAfter', ['v3', 'private'], 'POST', {'cost': 1})
+    v3_private_post_account_tradingmode = v3PrivatePostAccountTradingMode = Entry('account/tradingMode', ['v3', 'private'], 'POST', {'cost': 120})
+    v3_private_post_account_listenkey = v3PrivatePostAccountListenKey = Entry('account/listenKey', ['v3', 'private'], 'POST', {'cost': 20})
+    v3_private_post_asset_transfer = v3PrivatePostAssetTransfer = Entry('asset/transfer', ['v3', 'private'], 'POST', {'cost': 30})
+    v3_private_post_asset_wallet_withdraw = v3PrivatePostAssetWalletWithdraw = Entry('asset/wallet/withdraw', ['v3', 'private'], 'POST', {'cost': 60})
+    v3_private_post_spotmargin_leverage = v3PrivatePostSpotMarginLeverage = Entry('spotMargin/leverage', ['v3', 'private'], 'POST', {'cost': 120})
+    v3_private_post_spotmargin_interestrepay = v3PrivatePostSpotMarginInterestRepay = Entry('spotMargin/interestRepay', ['v3', 'private'], 'POST', {'cost': 60})
     v3_private_post_algo_order = v3PrivatePostAlgoOrder = Entry('algo/order', ['v3', 'private'], 'POST', {'cost': 5})
     v3_private_post_convert_rft = v3PrivatePostConvertRft = Entry('convert/rft', ['v3', 'private'], 'POST', {'cost': 60})
+    v3_private_put_trade_order = v3PrivatePutTradeOrder = Entry('trade/order', ['v3', 'private'], 'PUT', {'cost': 2})
+    v3_private_put_trade_algoorder = v3PrivatePutTradeAlgoOrder = Entry('trade/algoOrder', ['v3', 'private'], 'PUT', {'cost': 2})
+    v3_private_put_futures_leverage = v3PrivatePutFuturesLeverage = Entry('futures/leverage', ['v3', 'private'], 'PUT', {'cost': 60})
+    v3_private_put_futures_positionmode = v3PrivatePutFuturesPositionMode = Entry('futures/positionMode', ['v3', 'private'], 'PUT', {'cost': 120})
     v3_private_put_order_oid = v3PrivatePutOrderOid = Entry('order/{oid}', ['v3', 'private'], 'PUT', {'cost': 2})
     v3_private_put_order_client_client_order_id = v3PrivatePutOrderClientClientOrderId = Entry('order/client/{client_order_id}', ['v3', 'private'], 'PUT', {'cost': 2})
     v3_private_put_algo_order_oid = v3PrivatePutAlgoOrderOid = Entry('algo/order/{oid}', ['v3', 'private'], 'PUT', {'cost': 2})
     v3_private_put_algo_order_client_client_order_id = v3PrivatePutAlgoOrderClientClientOrderId = Entry('algo/order/client/{client_order_id}', ['v3', 'private'], 'PUT', {'cost': 2})
+    v3_private_delete_trade_order = v3PrivateDeleteTradeOrder = Entry('trade/order', ['v3', 'private'], 'DELETE', {'cost': 1})
+    v3_private_delete_trade_orders = v3PrivateDeleteTradeOrders = Entry('trade/orders', ['v3', 'private'], 'DELETE', {'cost': 1})
+    v3_private_delete_trade_algoorder = v3PrivateDeleteTradeAlgoOrder = Entry('trade/algoOrder', ['v3', 'private'], 'DELETE', {'cost': 1})
+    v3_private_delete_trade_algoorders = v3PrivateDeleteTradeAlgoOrders = Entry('trade/algoOrders', ['v3', 'private'], 'DELETE', {'cost': 1})
+    v3_private_delete_trade_allorders = v3PrivateDeleteTradeAllOrders = Entry('trade/allOrders', ['v3', 'private'], 'DELETE', {'cost': 1})
     v3_private_delete_algo_order_order_id = v3PrivateDeleteAlgoOrderOrderId = Entry('algo/order/{order_id}', ['v3', 'private'], 'DELETE', {'cost': 1})
     v3_private_delete_algo_orders_pending = v3PrivateDeleteAlgoOrdersPending = Entry('algo/orders/pending', ['v3', 'private'], 'DELETE', {'cost': 1})
     v3_private_delete_algo_orders_pending_symbol = v3PrivateDeleteAlgoOrdersPendingSymbol = Entry('algo/orders/pending/{symbol}', ['v3', 'private'], 'DELETE', {'cost': 1})

ccxt/async_support/__init__.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.4.94'
+__version__ = '4.4.95'
 
 # -----------------------------------------------------------------------------
 

ccxt/async_support/base/exchange.py

@@ -2,7 +2,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.4.94'
+__version__ = '4.4.95'
 
 # -----------------------------------------------------------------------------
 

ccxt/async_support/base/ws/future.py

@@ -36,6 +36,8 @@ class Future(asyncio.Future):
             elif cancelled:
                 future.cancel()
             else:
+                if future.cancelled():
+                    return
                 first_result = list(complete)[0].result()
                 future.set_result(first_result)
         task.add_done_callback(callback)

ccxt/async_support/bingx.py

@@ -128,6 +128,7 @@ class bingx(Exchange, ImplicitAPI):
                     'account': 'https://open-api.{hostname}/openApi',
                     'copyTrading': 'https://open-api.{hostname}/openApi',
                     'cswap': 'https://open-api.{hostname}/openApi',
+                    'api': 'https://open-api.{hostname}/openApi',
                 },
                 'test': {
                     'swap': 'https://open-api-vst.{hostname}/openApi',  # only swap is really "test" but since the API keys are the same, we want to keep all the functionalities when the user enables the sandboxmode
@@ -457,6 +458,7 @@ class bingx(Exchange, ImplicitAPI):
                         'private': {
                             'get': {
                                 'asset/transfer': 1,
+                                'asset/transferRecord': 5,
                                 'capital/deposit/hisrec': 1,
                                 'capital/withdraw/history': 1,
                             },
@@ -465,6 +467,20 @@ class bingx(Exchange, ImplicitAPI):
                             },
                         },
                     },
+                    'asset': {
+                        'v1': {
+                            'private': {
+                                'post': {
+                                    'transfer': 5,
+                                },
+                            },
+                            'public': {
+                                'get': {
+                                    'transfer/supportCoins': 5,
+                                },
+                            },
+                        },
+                    },
                 },
             },
             'timeframes': {
@@ -529,16 +545,19 @@ class bingx(Exchange, ImplicitAPI):
             'options': {
                 'defaultType': 'spot',
                 'accountsByType': {
-                    'funding': 'FUND',
-                    'spot': 'SPOT',
-                    'swap': 'PFUTURES',
-                    'future': 'SFUTURES',
+                    'funding': 'fund',
+                    'spot': 'spot',
+                    'future': 'stdFutures',
+                    'swap': 'USDTMPerp',
+                    'linear': 'USDTMPerp',
+                    'inverse': 'coinMPerp',
                 },
                 'accountsById': {
-                    'FUND': 'funding',
-                    'SPOT': 'spot',
-                    'PFUTURES': 'swap',
-                    'SFUTURES': 'future',
+                    'fund': 'funding',
+                    'spot': 'spot',
+                    'stdFutures': 'future',
+                    'USDTMPerp': 'linear',
+                    'coinMPerp': 'inverse',
                 },
                 'recvWindow': 5 * 1000,  # 5 sec
                 'broker': 'CCXT',
@@ -780,6 +799,10 @@ class bingx(Exchange, ImplicitAPI):
                         'min': self.safe_number(rawNetwork, 'withdrawMin'),
                         'max': self.safe_number(rawNetwork, 'withdrawMax'),
                     },
+                    'deposit': {
+                        'min': self.safe_number(rawNetwork, 'depositMin'),
+                        'max': None,
+                    },
                 }
                 precision = self.parse_number(self.parse_precision(self.safe_string(rawNetwork, 'withdrawPrecision')))
                 networks[networkCode] = {
@@ -793,20 +816,35 @@ class bingx(Exchange, ImplicitAPI):
                     'precision': precision,
                     'limits': limits,
                 }
-            result[code] = self.safe_currency_structure({
-                'info': entry,
-                'code': code,
-                'id': currencyId,
-                'precision': None,
-                'name': name,
-                'active': None,
-                'deposit': None,
-                'withdraw': None,
-                'networks': networks,
-                'fee': None,
-                'limits': None,
-                'type': 'crypto',  # only cryptos now
-            })
+            if not (code in result):  # the exchange could return the same currency with different networks
+                result[code] = {
+                    'info': entry,
+                    'code': code,
+                    'id': currencyId,
+                    'precision': None,
+                    'name': name,
+                    'active': None,
+                    'deposit': None,
+                    'withdraw': None,
+                    'networks': networks,
+                    'fee': None,
+                    'limits': None,
+                    'type': 'crypto',  # only cryptos now
+                }
+            else:
+                existing = result[code]
+                existingNetworks = self.safe_dict(existing, 'networks', {})
+                newNetworkCodes = list(networks.keys())
+                for j in range(0, len(newNetworkCodes)):
+                    newNetworkCode = newNetworkCodes[j]
+                    if not (newNetworkCode in existingNetworks):
+                        existingNetworks[newNetworkCode] = networks[newNetworkCode]
+                result[code]['networks'] = existingNetworks
+        codes = list(result.keys())
+        for i in range(0, len(codes)):
+            code = codes[i]
+            currency = result[code]
+            result[code] = self.safe_currency_structure(currency)
         return result
 
     async def fetch_spot_markets(self, params) -> List[Market]:
@@ -4642,26 +4680,39 @@ class bingx(Exchange, ImplicitAPI):
         """
         transfer currency internally between wallets on the same account
 
-        https://bingx-api.github.io/docs/#/en-us/common/account-api.html#Asset%20Transfer
+        https://bingx-api.github.io/docs/#/en-us/common/account-api.html#Asset%20Transfer%20New
 
         :param str code: unified currency code
         :param float amount: amount to transfer
         :param str fromAccount: account to transfer from(spot, swap, futures, or funding)
-        :param str toAccount: account to transfer to(spot, swap, futures, or funding)
+        :param str toAccount: account to transfer to(spot, swap(linear or inverse), future, or funding)
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: a `transfer structure <https://docs.ccxt.com/#/?id=transfer-structure>`
         """
         await self.load_markets()
         currency = self.currency(code)
         accountsByType = self.safe_dict(self.options, 'accountsByType', {})
+        subType = None
+        subType, params = self.handle_sub_type_and_params('transfer', None, params)
         fromId = self.safe_string(accountsByType, fromAccount, fromAccount)
         toId = self.safe_string(accountsByType, toAccount, toAccount)
+        if fromId == 'swap':
+            if subType == 'inverse':
+                fromId = 'coinMPerp'
+            else:
+                fromId = 'USDTMPerp'
+        if toId == 'swap':
+            if subType == 'inverse':
+                toId = 'coinMPerp'
+            else:
+                toId = 'USDTMPerp'
         request: dict = {
+            'fromAccount': fromId,
+            'toAccount': toId,
             'asset': currency['id'],
             'amount': self.currency_to_precision(code, amount),
-            'type': fromId + '_' + toId,
         }
-        response = await self.spotV3PrivateGetGetAssetTransfer(self.extend(request, params))
+        response = await self.apiAssetV1PrivatePostTransfer(self.extend(request, params))
         #
         #     {
         #         "tranId": 1933130865269936128,
@@ -4670,7 +4721,7 @@ class bingx(Exchange, ImplicitAPI):
         #
         return {
             'info': response,
-            'id': self.safe_string(response, 'tranId'),
+            'id': self.safe_string(response, 'transferId'),
             'timestamp': None,
             'datetime': None,
             'currency': code,
@@ -4684,18 +4735,19 @@ class bingx(Exchange, ImplicitAPI):
         """
         fetch a history of internal transfers made on an account
 
-        https://bingx-api.github.io/docs/#/spot/account-api.html#Query%20User%20Universal%20Transfer%20History%20(USER_DATA)
+        https://bingx-api.github.io/docs/#/en-us/common/account-api.html#Asset%20transfer%20records%20new
 
         :param str [code]: unified currency code of the currency transferred
         :param int [since]: the earliest time in ms to fetch transfers for
         :param int [limit]: the maximum number of transfers structures to retrieve(default 10, max 100)
         :param dict [params]: extra parameters specific to the exchange API endpoint
-        :param str params.fromAccount:(mandatory) transfer from(spot, swap, futures, or funding)
-        :param str params.toAccount:(mandatory) transfer to(spot, swap, futures, or funding)
+        :param str params.fromAccount:(mandatory) transfer from(spot, swap(linear or inverse), future, or funding)
+        :param str params.toAccount:(mandatory) transfer to(spot, swap(linear or inverse), future, or funding)
         :param boolean [params.paginate]: whether to paginate the results(default False)
         :returns dict[]: a list of `transfer structures <https://docs.ccxt.com/#/?id=transfer-structure>`
         """
         await self.load_markets()
+        request: dict = {}
         currency = None
         if code is not None:
             currency = self.currency(code)
@@ -4705,34 +4757,36 @@ class bingx(Exchange, ImplicitAPI):
         fromId = self.safe_string(accountsByType, fromAccount, fromAccount)
         toId = self.safe_string(accountsByType, toAccount, toAccount)
         if fromId is None or toId is None:
-            raise ExchangeError(self.id + ' fromAccount & toAccount parameter are required')
+            raise ExchangeError(self.id + ' fromAccount & toAccount parameters are required')
+        if fromAccount is not None:
+            request['fromAccount'] = fromId
+        if toAccount is not None:
+            request['toAccount'] = toId
         params = self.omit(params, ['fromAccount', 'toAccount'])
         maxLimit = 100
         paginate = False
         paginate, params = self.handle_option_and_params(params, 'fetchTransfers', 'paginate', False)
         if paginate:
             return await self.fetch_paginated_call_dynamic('fetchTransfers', None, since, limit, params, maxLimit)
-        request: dict = {
-            'type': fromId + '_' + toId,
-        }
         if since is not None:
             request['startTime'] = since
         if limit is not None:
-            request['size'] = limit
+            request['pageSize'] = limit
         request, params = self.handle_until_option('endTime', request, params)
-        response = await self.spotV3PrivateGetAssetTransfer(self.extend(request, params))
+        response = await self.apiV3PrivateGetAssetTransferRecord(self.extend(request, params))
         #
         #     {
-        #         "total": 3,
+        #         "total": 2,
         #         "rows": [
         #             {
-        #                 "asset": "USDT",
-        #                 "amount": "100.00000000000000000000",
-        #                 "type": "FUND_SFUTURES",
+        #                 "asset": "LTC",
+        #                 "amount": "0.05000000000000000000",
         #                 "status": "CONFIRMED",
-        #                 "tranId": 1067594500957016069,
-        #                 "timestamp": 1658388859000
-        #             },
+        #                 "transferId": "1051461075661819338791",
+        #                 "timestamp": 1752202092000,
+        #                 "fromAccount": "spot",
+        #                 "toAccount": "USDTMPerp"
+        #             }
         #         ]
         #     }
         #
@@ -4740,15 +4794,14 @@ class bingx(Exchange, ImplicitAPI):
         return self.parse_transfers(rows, currency, since, limit)
 
     def parse_transfer(self, transfer: dict, currency: Currency = None) -> TransferEntry:
-        tranId = self.safe_string(transfer, 'tranId')
+        tranId = self.safe_string(transfer, 'transferId')
         timestamp = self.safe_integer(transfer, 'timestamp')
-        currencyCode = self.safe_currency_code(None, currency)
+        currencyId = self.safe_string(transfer, 'asset')
+        currencyCode = self.safe_currency_code(currencyId, currency)
         status = self.safe_string(transfer, 'status')
         accountsById = self.safe_dict(self.options, 'accountsById', {})
-        typeId = self.safe_string(transfer, 'type')
-        typeIdSplit = typeId.split('_')
-        fromId = self.safe_string(typeIdSplit, 0)
-        toId = self.safe_string(typeIdSplit, 1)
+        fromId = self.safe_string(transfer, 'fromAccount')
+        toId = self.safe_string(transfer, 'toAccount')
         fromAccount = self.safe_string(accountsById, fromId, fromId)
         toAccount = self.safe_string(accountsById, toId, toId)
         return {
@@ -5459,37 +5512,13 @@ class bingx(Exchange, ImplicitAPI):
 
     def parse_deposit_withdraw_fee(self, fee, currency: Currency = None):
         #
-        #    {
-        #        "coin": "BTC",
-        #        "name": "BTC",
-        #        "networkList": [
-        #          {
-        #            "name": "BTC",
-        #            "network": "BTC",
-        #            "isDefault": True,
-        #            "minConfirm": "2",
-        #            "withdrawEnable": True,
-        #            "withdrawFee": "0.00035",
-        #            "withdrawMax": "1.62842",
-        #            "withdrawMin": "0.0005"
-        #          },
-        #          {
-        #            "name": "BTC",
-        #            "network": "BEP20",
-        #            "isDefault": False,
-        #            "minConfirm": "15",
-        #            "withdrawEnable": True,
-        #            "withdrawFee": "0.00001",
-        #            "withdrawMax": "1.62734",
-        #            "withdrawMin": "0.0001"
-        #          }
-        #        ]
-        #    }
+        # currencie structure
         #
-        networkList = self.safe_list(fee, 'networkList', [])
-        networkListLength = len(networkList)
+        networks = self.safe_dict(fee, 'networks', {})
+        networkCodes = list(networks.keys())
+        networksLength = len(networkCodes)
         result: dict = {
-            'info': fee,
+            'info': networks,
             'withdraw': {
                 'fee': None,
                 'percentage': None,
@@ -5500,18 +5529,15 @@ class bingx(Exchange, ImplicitAPI):
             },
             'networks': {},
         }
-        if networkListLength != 0:
-            for i in range(0, networkListLength):
-                network = networkList[i]
-                networkId = self.safe_string(network, 'network')
-                isDefault = self.safe_bool(network, 'isDefault')
-                currencyCode = self.safe_string(currency, 'code')
-                networkCode = self.network_id_to_code(networkId, currencyCode)
+        if networksLength != 0:
+            for i in range(0, networksLength):
+                networkCode = networkCodes[i]
+                network = networks[networkCode]
                 result['networks'][networkCode] = {
                     'deposit': {'fee': None, 'percentage': None},
-                    'withdraw': {'fee': self.safe_number(network, 'withdrawFee'), 'percentage': False},
+                    'withdraw': {'fee': self.safe_number(network, 'fee'), 'percentage': False},
                 }
-                if isDefault:
+                if networksLength == 1:
                     result['withdraw']['fee'] = self.safe_number(network, 'withdrawFee')
                     result['withdraw']['percentage'] = False
         return result
@@ -5527,9 +5553,15 @@ class bingx(Exchange, ImplicitAPI):
         :returns dict: a list of `fee structures <https://docs.ccxt.com/#/?id=fee-structure>`
         """
         await self.load_markets()
-        response = await self.walletsV1PrivateGetCapitalConfigGetall(params)
-        coins = self.safe_list(response, 'data')
-        return self.parse_deposit_withdraw_fees(coins, codes, 'coin')
+        response = await self.fetch_currencies(params)
+        depositWithdrawFees: dict = {}
+        responseCodes = list(response.keys())
+        for i in range(0, len(responseCodes)):
+            code = responseCodes[i]
+            if (codes is None) or (self.in_array(code, codes)):
+                entry = response[code]
+                depositWithdrawFees[code] = self.parse_deposit_withdraw_fee(entry)
+        return depositWithdrawFees
 
     async def withdraw(self, code: str, amount: float, address: str, tag=None, params={}) -> Transaction:
         """
@@ -6229,8 +6261,13 @@ class bingx(Exchange, ImplicitAPI):
             raise NotSupported(self.id + ' does not have a testnet/sandbox URL for ' + type + ' endpoints')
         url = self.implode_hostname(self.urls['api'][type])
         path = self.implode_params(path, params)
-        if version == 'transfer':
-            type = 'account/transfer'
+        versionIsTransfer = (version == 'transfer')
+        versionIsAsset = (version == 'asset')
+        if versionIsTransfer or versionIsAsset:
+            if versionIsTransfer:
+                type = 'account/transfer'
+            else:
+                type = 'api/asset'
             version = section[2]
             access = section[3]
         if path != 'account/apiPermissions':

ccxt/async_support/bitget.py

@@ -1998,7 +1998,7 @@ class bitget(Exchange, ImplicitAPI):
                     'cross': hasCrossMargin,
                     'isolated': hasIsolatedMargin,
                 }
-                isMarginTradingAllowed = hasCrossMargin or hasCrossMargin
+                isMarginTradingAllowed = hasCrossMargin or hasIsolatedMargin
             else:
                 if symbolType == 'perpetual':
                     type = 'swap'

ccxt/async_support/bitstamp.py

@@ -11,6 +11,7 @@ from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
 from ccxt.base.errors import PermissionDenied
+from ccxt.base.errors import AccountSuspended
 from ccxt.base.errors import BadRequest
 from ccxt.base.errors import InsufficientFunds
 from ccxt.base.errors import InvalidAddress
@@ -531,6 +532,7 @@ class bitstamp(Exchange, ImplicitAPI):
                     "Bitstamp.net is under scheduled maintenance. We'll be back soon.": OnMaintenance,  # {"error": "Bitstamp.net is under scheduled maintenance. We'll be back soon."}
                     'Order could not be placed.': ExchangeNotAvailable,  # Order could not be placed(perhaps due to internal error or trade halt). Please retry placing order.
                     'Invalid offset.': BadRequest,
+                    'Trading is currently unavailable for your account.': AccountSuspended,  # {"status": "error", "reason": {"__all__": ["Trading is currently unavailable for your account."]}, "response_code": "403.004"}
                 },
                 'broad': {
                     'Minimum order size is': InvalidOrder,  # Minimum order size is 5.0 EUR.

ccxt/async_support/blofin.py

@@ -904,6 +904,7 @@ class blofin(Exchange, ImplicitAPI):
         :param int [limit]: the maximum amount of `funding rate structures <https://docs.ccxt.com/#/?id=funding-rate-history-structure>` to fetch
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param boolean [params.paginate]: default False, when True will automatically paginate by calling self endpoint multiple times. See in the docs all the [availble parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
+        :param int [params.until]: timestamp in ms of the latest funding rate to fetch
         :returns dict[]: a list of `funding rate structures <https://docs.ccxt.com/#/?id=funding-rate-history-structure>`
         """
         if symbol is None:
@@ -912,7 +913,7 @@ class blofin(Exchange, ImplicitAPI):
         paginate = False
         paginate, params = self.handle_option_and_params(params, 'fetchFundingRateHistory', 'paginate')
         if paginate:
-            return await self.fetch_paginated_call_deterministic('fetchFundingRateHistory', symbol, since, limit, '8h', params)
+            return await self.fetch_paginated_call_deterministic('fetchFundingRateHistory', symbol, since, limit, '8h', params, 100)
         market = self.market(symbol)
         request: dict = {
             'instId': market['id'],
@@ -921,6 +922,10 @@ class blofin(Exchange, ImplicitAPI):
             request['before'] = max(since - 1, 0)
         if limit is not None:
             request['limit'] = limit
+        until = self.safe_integer(params, 'until')
+        if until is not None:
+            request['after'] = until
+            params = self.omit(params, 'until')
         response = await self.publicGetMarketFundingRateHistory(self.extend(request, params))
         rates = []
         data = self.safe_list(response, 'data', [])

ccxt/async_support/bybit.py

@@ -8083,7 +8083,7 @@ classic accounts only/ spot not supported*  fetches information on an order made
             'timestamp': timestamp,
             'datetime': self.iso8601(timestamp),
             'id': self.safe_string(income, 'execId'),
-            'amount': self.safe_number(income, 'execQty'),
+            'amount': self.safe_number(income, 'execFee'),
             'rate': self.safe_number(income, 'feeRate'),
         }