ccxt 4.4.93__tar.gz → 4.4.95__tar.gz

{ccxt-4.4.93/ccxt.egg-info → ccxt-4.4.95}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ccxt
-Version: 4.4.93
+Version: 4.4.95
 Summary: A JavaScript / TypeScript / Python / C# / PHP cryptocurrency trading library with support for 100+ exchanges
 Home-page: https://ccxt.com
 Author: Igor Kroitor
@@ -258,13 +258,13 @@ console.log(version, Object.keys(exchanges));
 
 All-in-one browser bundle (dependencies included), served from a CDN of your choice:
 
-* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@4.4.93/dist/ccxt.browser.min.js
-* unpkg: https://unpkg.com/ccxt@4.4.93/dist/ccxt.browser.min.js
+* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@4.4.95/dist/ccxt.browser.min.js
+* unpkg: https://unpkg.com/ccxt@4.4.95/dist/ccxt.browser.min.js
 
 CDNs are not updated in real-time and may have delays. Defaulting to the most recent version without specifying the version number is not recommended. Please, keep in mind that we are not responsible for the correct operation of those CDN servers.
 
 ```HTML
-<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@4.4.93/dist/ccxt.browser.min.js"></script>
+<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@4.4.95/dist/ccxt.browser.min.js"></script>
 ```
 
 Creates a global `ccxt` object:

{ccxt-4.4.93 → ccxt-4.4.95}/ccxt/__init__.py

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

{ccxt-4.4.93 → ccxt-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-4.4.93 → ccxt-4.4.95}/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-4.4.93 → ccxt-4.4.95}/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-4.4.93 → ccxt-4.4.95}/ccxt/async_support/__init__.py

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

{ccxt-4.4.93 → ccxt-4.4.95}/ccxt/async_support/base/exchange.py

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

{ccxt-4.4.93 → ccxt-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-4.4.93 → ccxt-4.4.95}/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-4.4.93 → ccxt-4.4.95}/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-4.4.93 → ccxt-4.4.95}/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-4.4.93 → ccxt-4.4.95}/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', [])