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

ccxt/async_support/ascendex.py

@@ -7,7 +7,7 @@ from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.ascendex import ImplicitAPI
 import asyncio
 import hashlib
-from ccxt.base.types import Account, Any, Balances, Bool, Currencies, Currency, DepositAddress, Int, Leverage, Leverages, LeverageTier, LeverageTiers, MarginMode, MarginModes, MarginModification, Market, Num, Order, OrderBook, OrderRequest, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, FundingRate, FundingRates, Trade, TradingFees, Transaction, TransferEntry
+from ccxt.base.types import Account, Any, Balances, Currencies, Currency, DepositAddress, Int, Leverage, Leverages, LeverageTier, LeverageTiers, MarginMode, MarginModes, MarginModification, Market, Num, Order, OrderBook, OrderRequest, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, FundingRate, FundingRates, Trade, TradingFees, Transaction, TransferEntry
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
@@ -478,6 +478,7 @@ class ascendex(Exchange, ImplicitAPI):
                 'broad': {},
             },
             'commonCurrencies': {
+                'XBT': 'XBT',  # self is not BTC ! just another token
                 'BOND': 'BONDED',
                 'BTCBEAR': 'BEAR',
                 'BTCBULL': 'BULL',
@@ -498,112 +499,82 @@ class ascendex(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: an associative dictionary of currencies
         """
-        assetsPromise = self.v1PublicGetAssets(params)
-        #
-        #     {
-        #         "code":0,
-        #         "data":[
-        #             {
-        #                 "assetCode" : "LTCBULL",
-        #                 "assetName" : "3X Long LTC Token",
-        #                 "precisionScale" : 9,
-        #                 "nativeScale" : 4,
-        #                 "withdrawalFee" : "0.2",
-        #                 "minWithdrawalAmt" : "1.0",
-        #                 "status" : "Normal"
-        #             },
-        #         ]
-        #     }
-        #
-        marginPromise = self.v1PublicGetMarginAssets(params)
-        #
-        #     {
-        #         "code":0,
-        #         "data":[
-        #             {
-        #                 "assetCode":"BTT",
-        #                 "displayName": "BTT",
-        #                 "borrowAssetCode":"BTT-B",
-        #                 "interestAssetCode":"BTT-I",
-        #                 "nativeScale":0,
-        #                 "numConfirmations":1,
-        #                 "withdrawFee":"100.0",
-        #                 "minWithdrawalAmt":"1000.0",
-        #                 "statusCode":"Normal",
-        #                 "statusMessage":"",
-        #                 "interestRate":"0.001"
-        #             }
-        #         ]
-        #     }
-        #
-        cashPromise = self.v1PublicGetCashAssets(params)
+        response = await self.v2PublicGetAssets(params)
         #
-        #     {
-        #         "code":0,
-        #         "data":[
-        #             {
-        #                 "assetCode":"LTCBULL",
-        #                 "displayName": "LTCBULL",
-        #                 "nativeScale":4,
-        #                 "numConfirmations":20,
-        #                 "withdrawFee":"0.2",
-        #                 "minWithdrawalAmt":"1.0",
-        #                 "statusCode":"Normal",
-        #                 "statusMessage":""  # hideFromWalletTx
-        #             }
+        #    {
+        #        "code": "0",
+        #        "data": [
+        #            {
+        #                "assetCode": "USDT",
+        #                "assetName": "Tether",
+        #                "precisionScale": 9,
+        #                "nativeScale": 4,
+        #                "blockChain": [
+        #                    {
+        #                        "chainName": "Solana",
+        #                        "withdrawFee": "2.0",
+        #                        "allowDeposit": True,
+        #                        "allowWithdraw": True,
+        #                        "minDepositAmt": "0.01",
+        #                        "minWithdrawal": "4.0",
+        #                        "numConfirmations": 1
+        #                    },
+        #                    ...
+        #                ]
+        #            },
         #         ]
-        #     }
+        #    }
         #
-        assets, margin, cash = await asyncio.gather(*[assetsPromise, marginPromise, cashPromise])
-        assetsData = self.safe_list(assets, 'data', [])
-        marginData = self.safe_list(margin, 'data', [])
-        cashData = self.safe_list(cash, 'data', [])
-        assetsById = self.index_by(assetsData, 'assetCode')
-        marginById = self.index_by(marginData, 'assetCode')
-        cashById = self.index_by(cashData, 'assetCode')
-        dataById = self.deep_extend(assetsById, marginById, cashById)
-        ids = list(dataById.keys())
+        data = self.safe_list(response, 'data', [])
         result: dict = {}
-        for i in range(0, len(ids)):
-            id = self.safe_string(ids, i)
-            currency = dataById[id]
+        for i in range(0, len(data)):
+            currency = data[i]
+            id = self.safe_string(currency, 'assetCode')
             code = self.safe_currency_code(id)
-            scale = self.safe_string_2(currency, 'precisionScale', 'nativeScale')
-            precision = self.parse_number(self.parse_precision(scale))
-            fee = self.safe_number_2(currency, 'withdrawFee', 'withdrawalFee')
-            status = self.safe_string(currency, 'status')
-            statusCode = self.safe_string(currency, 'statusCode')
-            active = (status == 'Normal')
-            depositEnabled: Bool = None
-            withdrawEnabled: Bool = None
-            if status == 'Delisted' or statusCode == 'hideFromWalletTx':
-                depositEnabled = False
-                withdrawEnabled = False
-            elif status == 'Normal':
-                depositEnabled = True
-                withdrawEnabled = True
-            elif status == 'NoTransaction' or statusCode == 'NoTransaction':
-                depositEnabled = True
-                withdrawEnabled = False
-            elif status == 'NoDeposit':
-                depositEnabled = False
-                withdrawEnabled = True
-            marginInside = ('borrowAssetCode' in currency)
-            result[code] = {
+            chains = self.safe_list(currency, 'blockChain', [])
+            precision = self.parse_number(self.parse_precision(self.safe_string(currency, 'nativeScale')))
+            networks = {}
+            for j in range(0, len(chains)):
+                networkEtnry = chains[j]
+                networkId = self.safe_string(networkEtnry, 'chainName')
+                networkCode = self.network_code_to_id(networkId)
+                networks[networkCode] = {
+                    'fee': self.safe_number(networkEtnry, 'withdrawFee'),
+                    'active': None,
+                    'withdraw': self.safe_bool(networkEtnry, 'allowWithdraw'),
+                    'deposit': self.safe_bool(networkEtnry, 'allowDeposit'),
+                    'precision': precision,
+                    'limits': {
+                        'amount': {
+                            'min': None,
+                            'max': None,
+                        },
+                        'withdraw': {
+                            'min': self.safe_number(networkEtnry, 'minWithdrawal'),
+                            'max': None,
+                        },
+                        'deposit': {
+                            'min': self.safe_number(networkEtnry, 'minDepositAmt'),
+                            'max': None,
+                        },
+                    },
+                }
+            # todo type: if chainsLength == 0 and (assetName.endswith(' Staking') or assetName.find(' Reward ') >= 0 or assetName.find('Slot Auction') >= 0 or assetName.find(' Freeze Asset') >= 0):
+            result[code] = self.safe_currency_structure({
                 'id': id,
                 'code': code,
                 'info': currency,
                 'type': None,
-                'margin': marginInside,
+                'margin': None,
                 'name': self.safe_string(currency, 'assetName'),
-                'active': active,
-                'deposit': depositEnabled,
-                'withdraw': withdrawEnabled,
-                'fee': fee,
+                'active': None,
+                'deposit': None,
+                'withdraw': None,
+                'fee': None,
                 'precision': precision,
                 'limits': {
                     'amount': {
-                        'min': precision,
+                        'min': None,
                         'max': None,
                     },
                     'withdraw': {
@@ -611,8 +582,8 @@ class ascendex(Exchange, ImplicitAPI):
                         'max': None,
                     },
                 },
-                'networks': {},  # todo
-            }
+                'networks': networks,
+            })
         return result
 
     async def fetch_markets(self, params={}) -> List[Market]:
@@ -621,6 +592,12 @@ class ascendex(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: an array of objects representing market data
         """
+        spotPromise = self.fetch_spot_markets(params)
+        contractPromise = self.fetch_contract_markets(params)
+        spotMarkets, contractMarkets = await asyncio.gather(*[spotPromise, contractPromise])
+        return self.array_concat(spotMarkets, contractMarkets)
+
+    async def fetch_spot_markets(self, params={}) -> List[Market]:
         productsPromise = self.v1PublicGetProducts(params)
         #
         #     {
@@ -672,7 +649,91 @@ class ascendex(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        perpetualsPromise = self.v2PublicGetFuturesContract(params)
+        products, cash = await asyncio.gather(*[productsPromise, cashPromise])
+        productsData = self.safe_list(products, 'data', [])
+        productsById = self.index_by(productsData, 'symbol')
+        cashData = self.safe_list(cash, 'data', [])
+        cashAndPerpetualsById = self.index_by(cashData, 'symbol')
+        dataById = self.deep_extend(productsById, cashAndPerpetualsById)
+        ids = list(dataById.keys())
+        result = []
+        for i in range(0, len(ids)):
+            id = ids[i]
+            if id.find('-PERP') >= 0:
+                continue  # skip perpetuals, endpoint returns them
+            market = dataById[id]
+            status = self.safe_string(market, 'status')
+            domain = self.safe_string(market, 'domain')
+            active = False
+            if ((status == 'Normal') or (status == 'InternalTrading')) and (domain != 'LeveragedETF'):
+                active = True
+            minQty = self.safe_number(market, 'minQty')
+            maxQty = self.safe_number(market, 'maxQty')
+            minPrice = self.safe_number(market, 'tickSize')
+            maxPrice: Num = None
+            underlying = self.safe_string_2(market, 'underlying', 'symbol')
+            parts = underlying.split('/')
+            baseId = self.safe_string(parts, 0)
+            quoteId = self.safe_string(parts, 1)
+            base = self.safe_currency_code(baseId)
+            quote = self.safe_currency_code(quoteId)
+            fee = self.safe_number(market, 'commissionReserveRate')
+            marginTradable = self.safe_bool(market, 'marginTradable', False)
+            result.append({
+                'id': id,
+                'symbol': base + '/' + quote,
+                'base': base,
+                'baseId': baseId,
+                'quote': quote,
+                'quoteId': quoteId,
+                'settle': None,
+                'settleId': None,
+                'type': 'spot',
+                'spot': True,
+                'margin': marginTradable,
+                'swap': False,
+                'future': False,
+                'option': False,
+                'active': active,
+                'contract': False,
+                'linear': None,
+                'inverse': None,
+                'taker': fee,
+                'maker': fee,
+                'contractSize': None,
+                'expiry': None,
+                'expiryDatetime': None,
+                'strike': None,
+                'optionType': None,
+                'precision': {
+                    'amount': self.safe_number(market, 'lotSize'),
+                    'price': self.safe_number(market, 'tickSize'),
+                },
+                'limits': {
+                    'leverage': {
+                        'min': None,
+                        'max': None,
+                    },
+                    'amount': {
+                        'min': minQty,
+                        'max': maxQty,
+                    },
+                    'price': {
+                        'min': minPrice,
+                        'max': maxPrice,
+                    },
+                    'cost': {
+                        'min': self.safe_number(market, 'minNotional'),
+                        'max': self.safe_number(market, 'maxNotional'),
+                    },
+                },
+                'created': self.safe_integer(market, 'tradingStartTime'),
+                'info': market,
+            })
+        return result
+
+    async def fetch_contract_markets(self, params={}) -> List[Market]:
+        contracts = await self.v2PublicGetFuturesContract(params)
         #
         #    {
         #        "code": 0,
@@ -685,9 +746,9 @@ class ascendex(Exchange, ImplicitAPI):
         #                "underlying": "BTC/USDT",
         #                "tradingStartTime": 1579701600000,
         #                "priceFilter": {
-        #                    "minPrice": "1",
+        #                    "minPrice": "0.1",
         #                    "maxPrice": "1000000",
-        #                    "tickSize": "1"
+        #                    "tickSize": "0.1"
         #                },
         #                "lotSizeFilter": {
         #                    "minQty": "0.0001",
@@ -710,50 +771,25 @@ class ascendex(Exchange, ImplicitAPI):
         #        ]
         #    }
         #
-        products, cash, perpetuals = await asyncio.gather(*[productsPromise, cashPromise, perpetualsPromise])
-        productsData = self.safe_list(products, 'data', [])
-        productsById = self.index_by(productsData, 'symbol')
-        cashData = self.safe_list(cash, 'data', [])
-        perpetualsData = self.safe_list(perpetuals, 'data', [])
-        cashAndPerpetualsData = self.array_concat(cashData, perpetualsData)
-        cashAndPerpetualsById = self.index_by(cashAndPerpetualsData, 'symbol')
-        dataById = self.deep_extend(productsById, cashAndPerpetualsById)
-        ids = list(dataById.keys())
+        data = self.safe_list(contracts, 'data', [])
         result = []
-        for i in range(0, len(ids)):
-            id = ids[i]
-            market = dataById[id]
-            settleId = self.safe_string(market, 'settlementAsset')
-            settle = self.safe_currency_code(settleId)
-            status = self.safe_string(market, 'status')
-            domain = self.safe_string(market, 'domain')
-            active = False
-            if ((status == 'Normal') or (status == 'InternalTrading')) and (domain != 'LeveragedETF'):
-                active = True
-            spot = settle is None
-            swap = not spot
-            linear = True if swap else None
-            minQty = self.safe_number(market, 'minQty')
-            maxQty = self.safe_number(market, 'maxQty')
-            minPrice = self.safe_number(market, 'tickSize')
-            maxPrice: Num = None
-            underlying = self.safe_string_2(market, 'underlying', 'symbol')
+        for i in range(0, len(data)):
+            market = data[i]
+            id = self.safe_string(market, 'symbol')
+            underlying = self.safe_string(market, 'underlying')
             parts = underlying.split('/')
             baseId = self.safe_string(parts, 0)
-            quoteId = self.safe_string(parts, 1)
             base = self.safe_currency_code(baseId)
+            quoteId = self.safe_string(parts, 1)
             quote = self.safe_currency_code(quoteId)
-            symbol = base + '/' + quote
-            if swap:
-                lotSizeFilter = self.safe_dict(market, 'lotSizeFilter')
-                minQty = self.safe_number(lotSizeFilter, 'minQty')
-                maxQty = self.safe_number(lotSizeFilter, 'maxQty')
-                priceFilter = self.safe_dict(market, 'priceFilter')
-                minPrice = self.safe_number(priceFilter, 'minPrice')
-                maxPrice = self.safe_number(priceFilter, 'maxPrice')
-                symbol = base + '/' + quote + ':' + settle
+            settleId = self.safe_string(market, 'settlementAsset')
+            settle = self.safe_currency_code(settleId)
+            linear = settle == quote
+            inverse = settle == base
+            symbol = base + '/' + quote + ':' + settle
+            priceFilter = self.safe_dict(market, 'priceFilter')
+            lotSizeFilter = self.safe_dict(market, 'lotSizeFilter')
             fee = self.safe_number(market, 'commissionReserveRate')
-            marginTradable = self.safe_bool(market, 'marginTradable', False)
             result.append({
                 'id': id,
                 'symbol': symbol,
@@ -763,26 +799,26 @@ class ascendex(Exchange, ImplicitAPI):
                 'baseId': baseId,
                 'quoteId': quoteId,
                 'settleId': settleId,
-                'type': 'swap' if swap else 'spot',
-                'spot': spot,
-                'margin': marginTradable if spot else None,
-                'swap': swap,
+                'type': 'swap',
+                'spot': False,
+                'margin': None,
+                'swap': True,
                 'future': False,
                 'option': False,
-                'active': active,
-                'contract': swap,
+                'active': self.safe_string(market, 'status') == 'Normal',
+                'contract': True,
                 'linear': linear,
-                'inverse': not linear if swap else None,
+                'inverse': inverse,
                 'taker': fee,
                 'maker': fee,
-                'contractSize': self.parse_number('1') if swap else None,
+                'contractSize': self.parse_number('1'),
                 'expiry': None,
                 'expiryDatetime': None,
                 'strike': None,
                 'optionType': None,
                 'precision': {
-                    'amount': self.safe_number(market, 'lotSize'),
-                    'price': self.safe_number(market, 'tickSize'),
+                    'amount': self.safe_number(lotSizeFilter, 'lotSize'),
+                    'price': self.safe_number(priceFilter, 'tickSize'),
                 },
                 'limits': {
                     'leverage': {
@@ -790,12 +826,12 @@ class ascendex(Exchange, ImplicitAPI):
                         'max': None,
                     },
                     'amount': {
-                        'min': minQty,
-                        'max': maxQty,
+                        'min': self.safe_number(lotSizeFilter, 'minQty'),
+                        'max': self.safe_number(lotSizeFilter, 'maxQty'),
                     },
                     'price': {
-                        'min': minPrice,
-                        'max': maxPrice,
+                        'min': self.safe_number(priceFilter, 'minPrice'),
+                        'max': self.safe_number(priceFilter, 'maxPrice'),
                     },
                     'cost': {
                         'min': self.safe_number(market, 'minNotional'),

ccxt/async_support/base/exchange.py

@@ -2,7 +2,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.4.85'
+__version__ = '4.4.87'
 
 # -----------------------------------------------------------------------------
 
@@ -176,15 +176,7 @@ class Exchange(BaseExchange):
             if (socksProxy not in self.socks_proxy_sessions):
                 # Create our SSL context object with our CA cert file
                 self.open()  # ensure `asyncio_loop` is set
-                self.aiohttp_socks_connector = ProxyConnector.from_url(
-                    socksProxy,
-                    # extra args copied from self.open()
-                    ssl=self.ssl_context,
-                    loop=self.asyncio_loop,
-                    enable_cleanup_closed=True
-                )
-                self.socks_proxy_sessions[socksProxy] = aiohttp.ClientSession(loop=self.asyncio_loop, connector=self.aiohttp_socks_connector, trust_env=self.aiohttp_trust_env)
-            proxy_session = self.socks_proxy_sessions[socksProxy]
+                proxy_session = self.get_socks_proxy_session(socksProxy)
         # add aiohttp_proxy for python as exclusion
         elif self.aiohttp_proxy:
             final_proxy = self.aiohttp_proxy
@@ -267,6 +259,20 @@ class Exchange(BaseExchange):
             return http_response
         return response.content
 
+    def get_socks_proxy_session(self, socksProxy):
+        if (self.socks_proxy_sessions is None):
+            self.socks_proxy_sessions = {}
+        if (socksProxy not in self.socks_proxy_sessions):
+            self.aiohttp_socks_connector = ProxyConnector.from_url(
+                socksProxy,
+                # extra args copied from self.open()
+                ssl=self.ssl_context,
+                loop=self.asyncio_loop,
+                enable_cleanup_closed=True
+            )
+            self.socks_proxy_sessions[socksProxy] = aiohttp.ClientSession(loop=self.asyncio_loop, connector=self.aiohttp_socks_connector, trust_env=self.aiohttp_trust_env)
+        return self.socks_proxy_sessions[socksProxy]
+
     async def load_markets_helper(self, reload=False, params={}):
         if not reload:
             if self.markets:
@@ -411,19 +417,12 @@ class Exchange(BaseExchange):
             # 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()
+            # set http/s proxy (socks proxy should be set in other place)
+            httpProxy, httpsProxy, socksProxy = self.check_ws_proxy_settings()
+            if (httpProxy or httpsProxy):
+                self.clients[url].proxy = httpProxy if httpProxy else httpsProxy
         return self.clients[url]
 
-    def get_ws_proxy(self):
-        httpProxy, httpsProxy, socksProxy = self.check_ws_proxy_settings()
-        if httpProxy:
-            return httpProxy
-        elif httpsProxy:
-            return httpsProxy
-        elif socksProxy:
-            return socksProxy
-        return None
-
     def delay(self, timeout, method, *args):
         return self.asyncio_loop.call_later(timeout / 1000, self.spawn, method, *args)
 
@@ -486,8 +485,13 @@ class Exchange(BaseExchange):
         if not subscribed:
             client.subscriptions[subscribe_hash] = subscription or True
 
+        selected_session = self.session
+        # http/s proxy is being set in other places
+        httpProxy, httpsProxy, socksProxy = self.check_ws_proxy_settings()
+        if (socksProxy):
+            selected_session = self.get_socks_proxy_session(socksProxy)
         connected = client.connected if client.connected.done() \
-            else asyncio.ensure_future(client.connect(self.session, backoff_delay))
+            else asyncio.ensure_future(client.connect(selected_session, backoff_delay))
 
         def after(fut):
             # todo: decouple signing from subscriptions
@@ -899,15 +903,15 @@ class Exchange(BaseExchange):
         if self.enableRateLimit:
             cost = self.calculate_rate_limiter_cost(api, method, path, params, config)
             await self.throttle(cost)
+        retries = None
+        retries, params = self.handle_option_and_params(params, path, 'maxRetriesOnFailure', 0)
+        retryDelay = None
+        retryDelay, params = self.handle_option_and_params(params, path, 'maxRetriesOnFailureDelay', 0)
         self.lastRestRequestTimestamp = self.milliseconds()
         request = self.sign(path, api, method, params, headers, body)
         self.last_request_headers = request['headers']
         self.last_request_body = request['body']
         self.last_request_url = request['url']
-        retries = None
-        retries, params = self.handle_option_and_params(params, path, 'maxRetriesOnFailure', 0)
-        retryDelay = None
-        retryDelay, params = self.handle_option_and_params(params, path, 'maxRetriesOnFailureDelay', 0)
         for i in range(0, retries + 1):
             try:
                 return await self.fetch(request['url'], request['method'], request['headers'], request['body'])

ccxt/async_support/bequant.py

@@ -14,8 +14,8 @@ class bequant(hitbtc, ImplicitAPI):
         return self.deep_extend(super(bequant, self).describe(), {
             'id': 'bequant',
             'name': 'Bequant',
-            'countries': ['MT'],  # Malta
             'pro': True,
+            'countries': ['MT'],  # Malta
             'urls': {
                 'logo': 'https://github.com/user-attachments/assets/0583ef1f-29fe-4b7c-8189-63565a0e2867',
                 'api': {

ccxt/async_support/binance.py

@@ -5024,13 +5024,13 @@ class binance(Exchange, ImplicitAPI):
         postOnly = self.is_post_only(initialUppercaseType == 'MARKET', initialUppercaseType == 'LIMIT_MAKER', params)
         if postOnly:
             uppercaseType = 'LIMIT_MAKER'
-        request['type'] = uppercaseType
         triggerPrice = self.safe_number_2(params, 'stopPrice', 'triggerPrice')
         if triggerPrice is not None:
             if uppercaseType == 'MARKET':
                 uppercaseType = 'STOP_LOSS'
             elif uppercaseType == 'LIMIT':
                 uppercaseType = 'STOP_LOSS_LIMIT'
+        request['type'] = uppercaseType
         validOrderTypes = self.safe_list(market['info'], 'orderTypes')
         if not self.in_array(uppercaseType, validOrderTypes):
             if initialUppercaseType != uppercaseType:

ccxt/async_support/bitget.py

@@ -2371,7 +2371,7 @@ class bitget(Exchange, ImplicitAPI):
             'coin': currency['id'],
             'address': address,
             'chain': networkId,
-            'size': amount,
+            'size': self.currency_to_precision(code, amount, networkCode),
             'transferType': 'on_chain',
         }
         if tag is not None:
@@ -2395,8 +2395,6 @@ class bitget(Exchange, ImplicitAPI):
         fillResponseFromRequest = self.safe_bool(withdrawOptions, 'fillResponseFromRequest', True)
         if fillResponseFromRequest:
             result['currency'] = code
-            result['timestamp'] = self.milliseconds()
-            result['datetime'] = self.iso8601(self.milliseconds())
             result['amount'] = amount
             result['tag'] = tag
             result['address'] = address
@@ -2514,7 +2512,9 @@ class bitget(Exchange, ImplicitAPI):
         status = self.safe_string(transaction, 'status')
         tag = self.safe_string(transaction, 'tag')
         feeCostString = self.safe_string(transaction, 'fee')
-        feeCostAbsString = Precise.string_abs(feeCostString)
+        feeCostAbsString = None
+        if feeCostString is not None:
+            feeCostAbsString = Precise.string_abs(feeCostString)
         fee = None
         amountString = self.safe_string(transaction, 'size')
         if feeCostAbsString is not None:

ccxt/async_support/bitmart.py

@@ -2306,7 +2306,7 @@ class bitmart(Exchange, ImplicitAPI):
                 code = self.safe_currency_code(currencyId)
                 account = self.account()
                 account['free'] = self.safe_string_2(balance, 'available', 'available_balance')
-                account['used'] = self.safe_string_2(balance, 'frozen', 'frozen_balance')
+                account['used'] = self.safe_string_n(balance, ['unAvailable', 'frozen', 'frozen_balance'])
                 result[code] = account
             return self.safe_balance(result)