ccxt 4.4.82__py2.py3-none-any.whl → 4.4.86__py2.py3-none-any.whl

ccxt/async_support/okcoin.py

@@ -840,47 +840,30 @@ class okcoin(Exchange, ImplicitAPI):
             return None
         else:
             response = await self.privateGetAssetCurrencies(params)
-            data = self.safe_value(response, 'data', [])
+            data = self.safe_list(response, 'data', [])
             result: dict = {}
             dataByCurrencyId = self.group_by(data, 'ccy')
             currencyIds = list(dataByCurrencyId.keys())
             for i in range(0, len(currencyIds)):
                 currencyId = currencyIds[i]
-                currency = self.safe_currency(currencyId)
-                code = currency['code']
+                code = self.safe_currency_code(currencyId)
                 chains = dataByCurrencyId[currencyId]
                 networks: dict = {}
-                currencyActive = False
-                depositEnabled = False
-                withdrawEnabled = False
-                maxPrecision = None
                 for j in range(0, len(chains)):
                     chain = chains[j]
-                    canDeposit = self.safe_value(chain, 'canDep')
-                    depositEnabled = canDeposit if (canDeposit) else depositEnabled
-                    canWithdraw = self.safe_value(chain, 'canWd')
-                    withdrawEnabled = canWithdraw if (canWithdraw) else withdrawEnabled
-                    canInternal = self.safe_value(chain, 'canInternal')
-                    active = True if (canDeposit and canWithdraw and canInternal) else False
-                    currencyActive = active if (active) else currencyActive
                     networkId = self.safe_string(chain, 'chain')
                     if (networkId is not None) and (networkId.find('-') >= 0):
                         parts = networkId.split('-')
                         chainPart = self.safe_string(parts, 1, networkId)
                         networkCode = self.network_id_to_code(chainPart)
-                        precision = self.parse_precision(self.safe_string(chain, 'wdTickSz'))
-                        if maxPrecision is None:
-                            maxPrecision = precision
-                        else:
-                            maxPrecision = Precise.string_min(maxPrecision, precision)
                         networks[networkCode] = {
                             'id': networkId,
                             'network': networkCode,
-                            'active': active,
-                            'deposit': canDeposit,
-                            'withdraw': canWithdraw,
+                            'active': None,
+                            'deposit': self.safe_bool(chain, 'canDep'),
+                            'withdraw': self.safe_bool(chain, 'canWd'),
                             'fee': self.safe_number(chain, 'minFee'),
-                            'precision': self.parse_number(precision),
+                            'precision': self.parse_number(self.parse_precision(self.safe_string(chain, 'wdTickSz'))),
                             'limits': {
                                 'withdraw': {
                                     'min': self.safe_number(chain, 'minWd'),
@@ -890,16 +873,16 @@ class okcoin(Exchange, ImplicitAPI):
                             'info': chain,
                         }
                 firstChain = self.safe_value(chains, 0)
-                result[code] = {
+                result[code] = self.safe_currency_structure({
                     'info': chains,
                     'code': code,
                     'id': currencyId,
                     'name': self.safe_string(firstChain, 'name'),
-                    'active': currencyActive,
-                    'deposit': depositEnabled,
-                    'withdraw': withdrawEnabled,
+                    'active': None,
+                    'deposit': None,
+                    'withdraw': None,
                     'fee': None,
-                    'precision': self.parse_number(maxPrecision),
+                    'precision': None,
                     'limits': {
                         'amount': {
                             'min': None,
@@ -907,7 +890,7 @@ class okcoin(Exchange, ImplicitAPI):
                         },
                     },
                     'networks': networks,
-                }
+                })
             return result
 
     async def fetch_order_book(self, symbol: str, limit: Int = None, params={}) -> OrderBook:

ccxt/async_support/okx.py

@@ -389,6 +389,7 @@ class okx(Exchange, ImplicitAPI):
                         'account/spot-manual-borrow-repay': 10,
                         'account/set-auto-repay': 4,
                         'account/spot-borrow-repay-history': 4,
+                        'account/move-positions-history': 10,
                         # subaccount
                         'users/subaccount/list': 10,
                         'account/subaccount/balances': 10 / 3,
@@ -526,6 +527,7 @@ class okx(Exchange, ImplicitAPI):
                         'account/fixed-loan/manual-reborrow': 5,
                         'account/fixed-loan/repay-borrowing-order': 5,
                         'account/bills-history-archive': 72000,  # 12 req/day
+                        'account/move-positions': 10,
                         # subaccount
                         'users/subaccount/modify-apikey': 10,
                         'asset/subaccount/transfer': 10,
@@ -992,6 +994,13 @@ class okx(Exchange, ImplicitAPI):
                     '70010': BadRequest,  # Timestamp parameters need to be in Unix timestamp format in milliseconds.
                     '70013': BadRequest,  # endTs needs to be bigger than or equal to beginTs.
                     '70016': BadRequest,  # Please specify your instrument settings for at least one instType.
+                    '70060': BadRequest,  # The account doesn’t exist or the position side is incorrect. To and from accounts must be under the same main account.
+                    '70061': BadRequest,  # To move position, please enter a position that’s opposite to your current side and is smaller than or equal to your current size.
+                    '70062': BadRequest,  # account has reached the maximum number of position transfers allowed per day.
+                    '70064': BadRequest,  # Position does not exist.
+                    '70065': BadRequest,  # Couldn’t move position. Execution price cannot be determined
+                    '70066': BadRequest,  # Moving positions isn't supported in spot mode. Switch to any other account mode and try again.
+                    '70067': BadRequest,  # Moving positions isn't supported in margin trading.
                     '1009': BadRequest,  # Request message exceeds the maximum frame length
                     '4001': AuthenticationError,  # Login Failed
                     '4002': BadRequest,  # Invalid Request

ccxt/async_support/onetrading.py

@@ -405,9 +405,12 @@ class onetrading(Exchange, ImplicitAPI):
         #
         #     [
         #         {
-        #             "code":"BEST",
-        #             "precision":8
-        #         }
+        #             "code": "USDT",
+        #             "precision": 6,
+        #             "unified_cryptoasset_id": 825,
+        #             "name": "Tether USDt",
+        #             "collateral_percentage": 0
+        #         },
         #     ]
         #
         result: dict = {}
@@ -415,11 +418,11 @@ class onetrading(Exchange, ImplicitAPI):
             currency = response[i]
             id = self.safe_string(currency, 'code')
             code = self.safe_currency_code(id)
-            result[code] = {
+            result[code] = self.safe_currency_structure({
                 'id': id,
                 'code': code,
-                'name': None,
-                'info': currency,  # the original payload
+                'name': self.safe_string(currency, 'name'),
+                'info': currency,
                 'active': None,
                 'fee': None,
                 'precision': self.parse_number(self.parse_precision(self.safe_string(currency, 'precision'))),
@@ -430,7 +433,7 @@ class onetrading(Exchange, ImplicitAPI):
                     'withdraw': {'min': None, 'max': None},
                 },
                 'networks': {},
-            }
+            })
         return result
 
     async def fetch_markets(self, params={}) -> List[Market]:

ccxt/async_support/oxfun.py

@@ -25,7 +25,6 @@ from ccxt.base.errors import NetworkError
 from ccxt.base.errors import RateLimitExceeded
 from ccxt.base.errors import RequestTimeout
 from ccxt.base.decimal_to_precision import TICK_SIZE
-from ccxt.base.precise import Precise
 
 
 class oxfun(Exchange, ImplicitAPI):
@@ -613,66 +612,7 @@ class oxfun(Exchange, ImplicitAPI):
         #                         "minDeposit": "0.00010",
         #                         "minWithdrawal": "0.00010"
         #                     },
-        #                     {
-        #                         "network": "Arbitrum",
-        #                         "tokenId": "0xba0Dda8762C24dA9487f5FA026a9B64b695A07Ea",
-        #                         "transactionPrecision": "18",
-        #                         "isWithdrawalFeeChargedToUser": True,
-        #                         "canDeposit": True,
-        #                         "canWithdraw": True,
-        #                         "minDeposit": "0.00010",
-        #                         "minWithdrawal": "0.00010"
-        #                     },
-        #                     {
-        #                         "network": "Ethereum",
-        #                         "tokenId": "0xba0Dda8762C24dA9487f5FA026a9B64b695A07Ea",
-        #                         "transactionPrecision": "18",
-        #                         "isWithdrawalFeeChargedToUser": True,
-        #                         "canDeposit": True,
-        #                         "canWithdraw": True,
-        #                         "minDeposit": "0.00010",
-        #                         "minWithdrawal": "0.00010"
-        #                     },
-        #                     {
-        #                         "network": "Arbitrum",
-        #                         "tokenId": "0x78a0A62Fba6Fb21A83FE8a3433d44C73a4017A6f",
-        #                         "transactionPrecision": "18",
-        #                         "isWithdrawalFeeChargedToUser": True,
-        #                         "canDeposit": True,
-        #                         "canWithdraw": False,
-        #                         "minDeposit": "0.00010",
-        #                         "minWithdrawal": "0.00010"
-        #                     },
-        #                     {
-        #                         "network": "Avalanche",
-        #                         "tokenId": "0x78a0A62Fba6Fb21A83FE8a3433d44C73a4017A6f",
-        #                         "transactionPrecision": "18",
-        #                         "isWithdrawalFeeChargedToUser": True,
-        #                         "canDeposit": True,
-        #                         "canWithdraw": False,
-        #                         "minDeposit": "0.00010",
-        #                         "minWithdrawal": "0.00010"
-        #                     },
-        #                     {
-        #                         "network": "Solana",
-        #                         "tokenId": "DV3845GEAVXfwpyVGGgWbqBVCtzHdCXNCGfcdboSEuZz",
-        #                         "transactionPrecision": "8",
-        #                         "isWithdrawalFeeChargedToUser": True,
-        #                         "canDeposit": True,
-        #                         "canWithdraw": True,
-        #                         "minDeposit": "0.00010",
-        #                         "minWithdrawal": "0.00010"
-        #                     },
-        #                     {
-        #                         "network": "Ethereum",
-        #                         "tokenId": "0x78a0A62Fba6Fb21A83FE8a3433d44C73a4017A6f",
-        #                         "transactionPrecision": "18",
-        #                         "isWithdrawalFeeChargedToUser": True,
-        #                         "canDeposit": True,
-        #                         "canWithdraw": False,
-        #                         "minDeposit": "0.00010",
-        #                         "minWithdrawal": "0.00010"
-        #                     }
+        #                     ...
         #                 ]
         #             },
         #             {
@@ -722,74 +662,64 @@ class oxfun(Exchange, ImplicitAPI):
             parts = fullId.split('.')
             id = parts[0]
             code = self.safe_currency_code(id)
-            networks: dict = {}
+            if not (code in result):
+                result[code] = {
+                    'id': id,
+                    'code': code,
+                    'precision': None,
+                    'type': None,
+                    'name': None,
+                    'active': None,
+                    'deposit': None,
+                    'withdraw': None,
+                    'fee': None,
+                    'limits': {
+                        'withdraw': {
+                            'min': None,
+                            'max': None,
+                        },
+                        'deposit': {
+                            'min': None,
+                            'max': None,
+                        },
+                    },
+                    'networks': {},
+                    'info': [],
+                }
             chains = self.safe_list(currency, 'networkList', [])
-            currencyMaxPrecision: Str = None
-            currencyDepositEnabled: Bool = None
-            currencyWithdrawEnabled: Bool = None
             for j in range(0, len(chains)):
                 chain = chains[j]
                 networkId = self.safe_string(chain, 'network')
                 networkCode = self.network_id_to_code(networkId)
-                deposit = self.safe_bool(chain, 'canDeposit')
-                withdraw = self.safe_bool(chain, 'canWithdraw')
-                active = (deposit and withdraw)
-                minDeposit = self.safe_string(chain, 'minDeposit')
-                minWithdrawal = self.safe_string(chain, 'minWithdrawal')
-                precision = self.parse_precision(self.safe_string(chain, 'transactionPrecision'))
-                networks[networkCode] = {
+                result[code]['networks'][networkCode] = {
                     'id': networkId,
                     'network': networkCode,
                     'margin': None,
-                    'deposit': deposit,
-                    'withdraw': withdraw,
-                    'active': active,
+                    'deposit': self.safe_bool(chain, 'canDeposit'),
+                    'withdraw': self.safe_bool(chain, 'canWithdraw'),
+                    'active': None,
                     'fee': None,
-                    'precision': self.parse_number(precision),
+                    'precision': self.parse_number(self.parse_precision(self.safe_string(chain, 'transactionPrecision'))),
                     'limits': {
                         'deposit': {
-                            'min': minDeposit,
+                            'min': self.safe_number(chain, 'minDeposit'),
                             'max': None,
                         },
                         'withdraw': {
-                            'min': minWithdrawal,
+                            'min': self.safe_number(chain, 'minWithdrawal'),
                             'max': None,
                         },
                     },
                     'info': chain,
                 }
-                if (currencyDepositEnabled is None) or deposit:
-                    currencyDepositEnabled = deposit
-                if (currencyWithdrawEnabled is None) or withdraw:
-                    currencyWithdrawEnabled = withdraw
-                if (currencyMaxPrecision is None) or Precise.string_gt(currencyMaxPrecision, precision):
-                    currencyMaxPrecision = precision
-            if code in result:
-                # checking for specific ids.ARB
-                networks = self.extend(result[code]['networks'], networks)
-            result[code] = {
-                'id': id,
-                'code': code,
-                'name': None,
-                'type': None,
-                'active': None,
-                'deposit': currencyDepositEnabled,
-                'withdraw': currencyWithdrawEnabled,
-                'fee': None,
-                'precision': self.parse_number(currencyMaxPrecision),
-                'limits': {
-                    'amount': {
-                        'min': None,
-                        'max': None,
-                    },
-                    'withdraw': {
-                        'min': None,
-                        'max': None,
-                    },
-                },
-                'networks': networks,
-                'info': currency,
-            }
+            infos = self.safe_list(result[code], 'info', [])
+            infos.append(currency)
+            result[code]['info'] = infos
+        # only after all entries are formed in currencies, restructure each entry
+        allKeys = list(result.keys())
+        for i in range(0, len(allKeys)):
+            code = allKeys[i]
+            result[code] = self.safe_currency_structure(result[code])  # self is needed after adding network entry
         return result
 
     async def fetch_tickers(self, symbols: Strings = None, params={}) -> Tickers:

ccxt/async_support/paradex.py

@@ -5,7 +5,7 @@
 
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.paradex import ImplicitAPI
-from ccxt.base.types import Any, Balances, Currency, Int, Leverage, MarginMode, Market, Num, Order, OrderBook, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, Trade, Transaction
+from ccxt.base.types import Any, Balances, Currency, Greeks, Int, Leverage, MarginMode, Market, Num, Order, OrderBook, OrderSide, OrderType, Position, Str, Strings, Ticker, Tickers, Trade, Transaction
 from typing import List
 from ccxt.base.errors import ExchangeError
 from ccxt.base.errors import AuthenticationError
@@ -75,6 +75,7 @@ class paradex(Exchange, ImplicitAPI):
                 'fetchFundingRate': False,
                 'fetchFundingRateHistory': False,
                 'fetchFundingRates': False,
+                'fetchGreeks': True,
                 'fetchIndexOHLCV': False,
                 'fetchIsolatedBorrowRate': False,
                 'fetchIsolatedBorrowRates': False,
@@ -558,13 +559,14 @@ class paradex(Exchange, ImplicitAPI):
         expiry = self.safe_integer(market, 'expiry_at')
         optionType = self.safe_string(market, 'option_type')
         strikePrice = self.safe_string(market, 'strike_price')
+        takerFee = self.parse_number('0.0003')
+        makerFee = self.parse_number('-0.00005')
         if isOption:
             optionTypeSuffix = 'C' if (optionType == 'CALL') else 'P'
             symbol = symbol + '-' + strikePrice + '-' + optionTypeSuffix
+            makerFee = self.parse_number('0.0003')
         else:
             expiry = None
-        takerFee = self.parse_number('0.0003')
-        makerFee = self.parse_number('-0.00005')
         return self.safe_market_structure({
             'id': marketId,
             'symbol': symbol,
@@ -1243,7 +1245,10 @@ class paradex(Exchange, ImplicitAPI):
         price = self.safe_string(order, 'price')
         amount = self.safe_string(order, 'size')
         orderType = self.safe_string(order, 'type')
+        cancelReason = self.safe_string(order, 'cancel_reason')
         status = self.safe_string(order, 'status')
+        if cancelReason is not None:
+            status = 'canceled'
         side = self.safe_string_lower(order, 'side')
         average = self.omit_zero(self.safe_string(order, 'avg_fill_price'))
         remaining = self.omit_zero(self.safe_string(order, 'remaining_size'))
@@ -1262,7 +1267,7 @@ class paradex(Exchange, ImplicitAPI):
             'status': self.parse_order_status(status),
             'symbol': symbol,
             'type': self.parse_order_type(orderType),
-            'timeInForce': self.parse_time_in_force(self.safe_string(order, 'instrunction')),
+            'timeInForce': self.parse_time_in_force(self.safe_string(order, 'instruction')),
             'postOnly': None,
             'reduceOnly': reduceOnly,
             'side': side,
@@ -2284,6 +2289,120 @@ class paradex(Exchange, ImplicitAPI):
         }
         return await self.privatePostAccountMarginMarket(self.extend(request, params))
 
+    async def fetch_greeks(self, symbol: str, params={}) -> Greeks:
+        """
+        fetches an option contracts greeks, financial metrics used to measure the factors that affect the price of an options contract
+
+        https://docs.api.testnet.paradex.trade/#list-available-markets-summary
+
+        :param str symbol: unified symbol of the market to fetch greeks for
+        :param dict [params]: extra parameters specific to the exchange API endpoint
+        :returns dict: a `greeks structure <https://docs.ccxt.com/#/?id=greeks-structure>`
+        """
+        await self.load_markets()
+        market = self.market(symbol)
+        request: dict = {
+            'market': market['id'],
+        }
+        response = await self.publicGetMarketsSummary(self.extend(request, params))
+        #
+        #     {
+        #         "results": [
+        #             {
+        #                 "symbol": "BTC-USD-114000-P",
+        #                 "mark_price": "10835.66892602",
+        #                 "mark_iv": "0.71781855",
+        #                 "delta": "-0.98726024",
+        #                 "greeks": {
+        #                     "delta": "-0.9872602390817709",
+        #                     "gamma": "0.000004560958862297231",
+        #                     "vega": "227.11344863639806",
+        #                     "rho": "-302.0617972461581",
+        #                     "vanna": "0.06609830491614832",
+        #                     "volga": "925.9501532805552"
+        #                 },
+        #                 "last_traded_price": "10551.5",
+        #                 "bid": "10794.9",
+        #                 "bid_iv": "0.05",
+        #                 "ask": "10887.3",
+        #                 "ask_iv": "0.8783283",
+        #                 "last_iv": "0.05",
+        #                 "volume_24h": "0",
+        #                 "total_volume": "195240.72672261014",
+        #                 "created_at": 1747644009995,
+        #                 "underlying_price": "103164.79162649",
+        #                 "open_interest": "0",
+        #                 "funding_rate": "0.000004464241170536191",
+        #                 "price_change_rate_24h": "0.074915",
+        #                 "future_funding_rate": "0.0001"
+        #             }
+        #         ]
+        #     }
+        #
+        data = self.safe_list(response, 'results', [])
+        greeks = self.safe_dict(data, 0, {})
+        return self.parse_greeks(greeks, market)
+
+    def parse_greeks(self, greeks: dict, market: Market = None) -> Greeks:
+        #
+        #     {
+        #         "symbol": "BTC-USD-114000-P",
+        #         "mark_price": "10835.66892602",
+        #         "mark_iv": "0.71781855",
+        #         "delta": "-0.98726024",
+        #         "greeks": {
+        #             "delta": "-0.9872602390817709",
+        #             "gamma": "0.000004560958862297231",
+        #             "vega": "227.11344863639806",
+        #             "rho": "-302.0617972461581",
+        #             "vanna": "0.06609830491614832",
+        #             "volga": "925.9501532805552"
+        #         },
+        #         "last_traded_price": "10551.5",
+        #         "bid": "10794.9",
+        #         "bid_iv": "0.05",
+        #         "ask": "10887.3",
+        #         "ask_iv": "0.8783283",
+        #         "last_iv": "0.05",
+        #         "volume_24h": "0",
+        #         "total_volume": "195240.72672261014",
+        #         "created_at": 1747644009995,
+        #         "underlying_price": "103164.79162649",
+        #         "open_interest": "0",
+        #         "funding_rate": "0.000004464241170536191",
+        #         "price_change_rate_24h": "0.074915",
+        #         "future_funding_rate": "0.0001"
+        #     }
+        #
+        marketId = self.safe_string(greeks, 'symbol')
+        market = self.safe_market(marketId, market, None, 'option')
+        symbol = market['symbol']
+        timestamp = self.safe_integer(greeks, 'created_at')
+        greeksData = self.safe_dict(greeks, 'greeks', {})
+        return {
+            'symbol': symbol,
+            'timestamp': timestamp,
+            'datetime': self.iso8601(timestamp),
+            'delta': self.safe_number(greeksData, 'delta'),
+            'gamma': self.safe_number(greeksData, 'gamma'),
+            'theta': None,
+            'vega': self.safe_number(greeksData, 'vega'),
+            'rho': self.safe_number(greeksData, 'rho'),
+            'vanna': self.safe_number(greeksData, 'vanna'),
+            'volga': self.safe_number(greeksData, 'volga'),
+            'bidSize': None,
+            'askSize': None,
+            'bidImpliedVolatility': self.safe_number(greeks, 'bid_iv'),
+            'askImpliedVolatility': self.safe_number(greeks, 'ask_iv'),
+            'markImpliedVolatility': self.safe_number(greeks, 'mark_iv'),
+            'bidPrice': self.safe_number(greeks, 'bid'),
+            'askPrice': self.safe_number(greeks, 'ask'),
+            'markPrice': self.safe_number(greeks, 'mark_price'),
+            'lastPrice': self.safe_number(greeks, 'last_traded_price'),
+            'underlyingPrice': self.safe_number(greeks, 'underlying_price'),
+            'info': greeks,
+        }
+
     def sign(self, path, api='public', method='GET', params={}, headers=None, body=None):
         url = self.implode_hostname(self.urls['api'][self.version]) + '/' + self.implode_params(path, params)
         query = self.omit(params, self.extract_params(path))

ccxt/base/exchange.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.4.82'
+__version__ = '4.4.86'
 
 # -----------------------------------------------------------------------------
 
@@ -1506,6 +1506,25 @@ class Exchange(object):
         return len(parts[1]) if len(parts) > 1 else 0
 
     def load_markets(self, reload=False, params={}):
+        """
+        Loads and prepares the markets for trading.
+
+        Args:
+            reload (bool): If True, the markets will be reloaded from the exchange.
+            params (dict): Additional exchange-specific parameters for the request.
+
+        Returns:
+            dict: A dictionary of markets.
+
+        Raises:
+            Exception: If the markets cannot be loaded or prepared.
+
+        Notes:
+            It ensures that the markets are only loaded once, even if called multiple times.
+            If the markets are already loaded and `reload` is False or not provided, it returns the existing markets.
+            If a reload is in progress, it waits for completion before returning.
+            If an error occurs during loading or preparation, an exception is raised.
+        """
         if not reload:
             if self.markets:
                 if not self.markets_by_id:
@@ -3008,7 +3027,7 @@ class Exchange(object):
                         currency['networks'][key]['active'] = True
                     elif deposit is not None and withdraw is not None:
                         currency['networks'][key]['active'] = False
-                active = self.safe_bool(network, 'active')
+                active = self.safe_bool(currency['networks'][key], 'active')  # dict might have been updated on above lines, so access directly instead of `network` variable
                 currencyActive = self.safe_bool(currency, 'active')
                 if currencyActive is None or active:
                     currency['active'] = active

ccxt/base/types.py

@@ -308,6 +308,9 @@ class Greeks(TypedDict):
     theta: Num
     vega: Num
     rho: Num
+    vanna: Num
+    volga: Num
+    charm: Num
     bidSize: Num
     askSize: Num
     bidImpliedVolatility: Num

ccxt/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/bitget.py

@@ -2071,8 +2071,7 @@ class bitget(Exchange, ImplicitAPI):
                 chain = chains[j]
                 networkId = self.safe_string(chain, 'chain')
                 network = self.network_id_to_code(networkId, code)
-                if network is not None:
-                    network = network.upper()
+                network = network.upper()
                 networks[network] = {
                     'info': chain,
                     'id': networkId,
@@ -2371,7 +2370,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 +2394,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 +2511,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/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)