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

ccxt/bitfinex.py

@@ -751,6 +751,7 @@ class bitfinex(Exchange, ImplicitAPI):
             'pub:map:currency:explorer',  # maps symbols to their recognised block explorer URLs
             'pub:map:currency:tx:fee',  # maps currencies to their withdrawal fees https://github.com/ccxt/ccxt/issues/7745,
             'pub:map:tx:method',  # maps withdrawal/deposit methods to their API symbols
+            'pub:info:tx:status',  # maps withdrawal/deposit statuses, coins: 1 = enabled, 0 = maintenance
         ]
         config = ','.join(labels)
         request: dict = {
@@ -833,40 +834,81 @@ class bitfinex(Exchange, ImplicitAPI):
         #             ["ABS",[0,131.3]],
         #             ["ADA",[0,0.3]],
         #         ],
+        #         # deposit/withdrawal data
+        #         [
+        #           ["BITCOIN", 1, 1, null, null, null, null, 0, 0, null, null, 3],
+        #           ...
+        #         ]
         #     ]
         #
         indexed: dict = {
-            'sym': self.index_by(self.safe_value(response, 1, []), 0),
-            'label': self.index_by(self.safe_value(response, 2, []), 0),
-            'unit': self.index_by(self.safe_value(response, 3, []), 0),
-            'undl': self.index_by(self.safe_value(response, 4, []), 0),
-            'pool': self.index_by(self.safe_value(response, 5, []), 0),
-            'explorer': self.index_by(self.safe_value(response, 6, []), 0),
-            'fees': self.index_by(self.safe_value(response, 7, []), 0),
+            'sym': self.index_by(self.safe_list(response, 1, []), 0),
+            'label': self.index_by(self.safe_list(response, 2, []), 0),
+            'unit': self.index_by(self.safe_list(response, 3, []), 0),
+            'undl': self.index_by(self.safe_list(response, 4, []), 0),
+            'pool': self.index_by(self.safe_list(response, 5, []), 0),
+            'explorer': self.index_by(self.safe_list(response, 6, []), 0),
+            'fees': self.index_by(self.safe_list(response, 7, []), 0),
+            'networks': self.safe_list(response, 8, []),
+            'statuses': self.index_by(self.safe_list(response, 9, []), 0),
         }
-        ids = self.safe_value(response, 0, [])
+        indexedNetworks: dict = {}
+        for i in range(0, len(indexed['networks'])):
+            networkObj = indexed['networks'][i]
+            networkId = self.safe_string(networkObj, 0)
+            valuesList = self.safe_list(networkObj, 1)
+            networkName = self.safe_string(valuesList, 0)
+            # for GOlang transpiler, do with "safe" method
+            networksList = self.safe_list(indexedNetworks, networkName, [])
+            networksList.append(networkId)
+            indexedNetworks[networkName] = networksList
+        ids = self.safe_list(response, 0, [])
         result: dict = {}
         for i in range(0, len(ids)):
             id = ids[i]
-            if id.find('F0') >= 0:
+            if id.endswith('F0'):
                 # we get a lot of F0 currencies, skip those
                 continue
             code = self.safe_currency_code(id)
-            label = self.safe_value(indexed['label'], id, [])
+            label = self.safe_list(indexed['label'], id, [])
             name = self.safe_string(label, 1)
-            pool = self.safe_value(indexed['pool'], id, [])
+            pool = self.safe_list(indexed['pool'], id, [])
             rawType = self.safe_string(pool, 1)
             isCryptoCoin = (rawType is not None) or (id in indexed['explorer'])  # "hacky" solution
             type = None
             if isCryptoCoin:
                 type = 'crypto'
-            feeValues = self.safe_value(indexed['fees'], id, [])
-            fees = self.safe_value(feeValues, 1, [])
+            feeValues = self.safe_list(indexed['fees'], id, [])
+            fees = self.safe_list(feeValues, 1, [])
             fee = self.safe_number(fees, 1)
-            undl = self.safe_value(indexed['undl'], id, [])
+            undl = self.safe_list(indexed['undl'], id, [])
             precision = '8'  # default precision, todo: fix "magic constants"
             fid = 'f' + id
-            result[code] = {
+            dwStatuses = self.safe_list(indexed['statuses'], id, [])
+            depositEnabled = self.safe_integer(dwStatuses, 1) == 1
+            withdrawEnabled = self.safe_integer(dwStatuses, 2) == 1
+            networks: dict = {}
+            netwokIds = self.safe_list(indexedNetworks, id, [])
+            for j in range(0, len(netwokIds)):
+                networkId = netwokIds[j]
+                network = self.network_id_to_code(networkId)
+                networks[network] = {
+                    'info': networkId,
+                    'id': networkId.lower(),
+                    'network': networkId,
+                    'active': None,
+                    'deposit': None,
+                    'withdraw': None,
+                    'fee': None,
+                    'precision': None,
+                    'limits': {
+                        'withdraw': {
+                            'min': None,
+                            'max': None,
+                        },
+                    },
+                }
+            result[code] = self.safe_currency_structure({
                 'id': fid,
                 'uppercaseId': id,
                 'code': code,
@@ -874,8 +916,8 @@ class bitfinex(Exchange, ImplicitAPI):
                 'type': type,
                 'name': name,
                 'active': True,
-                'deposit': None,
-                'withdraw': None,
+                'deposit': depositEnabled,
+                'withdraw': withdrawEnabled,
                 'fee': fee,
                 'precision': int(precision),
                 'limits': {
@@ -888,37 +930,8 @@ class bitfinex(Exchange, ImplicitAPI):
                         'max': None,
                     },
                 },
-                'networks': {},
-            }
-            networks: dict = {}
-            currencyNetworks = self.safe_value(response, 8, [])
-            cleanId = id.replace('F0', '')
-            for j in range(0, len(currencyNetworks)):
-                pair = currencyNetworks[j]
-                networkId = self.safe_string(pair, 0)
-                currencyId = self.safe_string(self.safe_value(pair, 1, []), 0)
-                if currencyId == cleanId:
-                    network = self.network_id_to_code(networkId)
-                    networks[network] = {
-                        'info': networkId,
-                        'id': networkId.lower(),
-                        'network': networkId,
-                        'active': None,
-                        'deposit': None,
-                        'withdraw': None,
-                        'fee': None,
-                        'precision': None,
-                        'limits': {
-                            'withdraw': {
-                                'min': None,
-                                'max': None,
-                            },
-                        },
-                    }
-            keysNetworks = list(networks.keys())
-            networksLength = len(keysNetworks)
-            if networksLength > 0:
-                result[code]['networks'] = networks
+                'networks': networks,
+            })
         return result
 
     def fetch_balance(self, params={}) -> Balances:
@@ -1150,9 +1163,8 @@ class bitfinex(Exchange, ImplicitAPI):
         #
         # on trading pairs(ex. tBTCUSD)
         #
-        #    {
-        #        'result': [
-        #            SYMBOL,
+        #    [
+        #            SYMBOL,  # self index is not present in singular-ticker
         #            BID,
         #            BID_SIZE,
         #            ASK,
@@ -1163,15 +1175,13 @@ class bitfinex(Exchange, ImplicitAPI):
         #            VOLUME,
         #            HIGH,
         #            LOW
-        #        ]
-        #    }
+        #    ]
         #
         #
         # on funding currencies(ex. fUSD)
         #
-        #    {
-        #        'result': [
-        #            SYMBOL,
+        #    [
+        #            SYMBOL,  # self index is not present in singular-ticker
         #            FRR,
         #            BID,
         #            BID_PERIOD,
@@ -1188,35 +1198,71 @@ class bitfinex(Exchange, ImplicitAPI):
         #            _PLACEHOLDER,
         #            _PLACEHOLDER,
         #            FRR_AMOUNT_AVAILABLE
-        #        ]
-        #    }
+        #     ]
         #
-        result = self.safe_list(ticker, 'result')
+        length = len(ticker)
+        isFetchTicker = (length == 10) or (length == 16)
+        symbol: Str = None
+        minusIndex = 0
+        isFundingCurrency = False
+        if isFetchTicker:
+            minusIndex = 1
+            isFundingCurrency = (length == 16)
+        else:
+            marketId = self.safe_string(ticker, 0)
+            market = self.safe_market(marketId, market)
+            isFundingCurrency = (length == 17)
         symbol = self.safe_symbol(None, market)
-        length = len(result)
-        last = self.safe_string(result, length - 4)
-        percentage = self.safe_string(result, length - 5)
+        last: Str = None
+        bid: Str = None
+        ask: Str = None
+        change: Str = None
+        percentage: Str = None
+        volume: Str = None
+        high: Str = None
+        low: Str = None
+        if isFundingCurrency:
+            # per api docs, they are different array type
+            last = self.safe_string(ticker, 10 - minusIndex)
+            bid = self.safe_string(ticker, 2 - minusIndex)
+            ask = self.safe_string(ticker, 5 - minusIndex)
+            change = self.safe_string(ticker, 8 - minusIndex)
+            percentage = self.safe_string(ticker, 9 - minusIndex)
+            volume = self.safe_string(ticker, 11 - minusIndex)
+            high = self.safe_string(ticker, 12 - minusIndex)
+            low = self.safe_string(ticker, 13 - minusIndex)
+        else:
+            # on trading pairs(ex. tBTCUSD or tHMSTR:USD)
+            last = self.safe_string(ticker, 7 - minusIndex)
+            bid = self.safe_string(ticker, 1 - minusIndex)
+            ask = self.safe_string(ticker, 3 - minusIndex)
+            change = self.safe_string(ticker, 5 - minusIndex)
+            percentage = self.safe_string(ticker, 6 - minusIndex)
+            percentage = Precise.string_mul(percentage, '100')
+            volume = self.safe_string(ticker, 8 - minusIndex)
+            high = self.safe_string(ticker, 9 - minusIndex)
+            low = self.safe_string(ticker, 10 - minusIndex)
         return self.safe_ticker({
             'symbol': symbol,
             'timestamp': None,
             'datetime': None,
-            'high': self.safe_string(result, length - 2),
-            'low': self.safe_string(result, length - 1),
-            'bid': self.safe_string(result, length - 10),
-            'bidVolume': self.safe_string(result, length - 9),
-            'ask': self.safe_string(result, length - 8),
-            'askVolume': self.safe_string(result, length - 7),
+            'high': high,
+            'low': low,
+            'bid': bid,
+            'bidVolume': None,
+            'ask': ask,
+            'askVolume': None,
             'vwap': None,
             'open': None,
             'close': last,
             'last': last,
             'previousClose': None,
-            'change': self.safe_string(result, length - 6),
-            'percentage': Precise.string_mul(percentage, '100'),
+            'change': change,
+            'percentage': percentage,
             'average': None,
-            'baseVolume': self.safe_string(result, length - 3),
+            'baseVolume': volume,
             'quoteVolume': None,
-            'info': result,
+            'info': ticker,
         }, market)
 
     def fetch_tickers(self, symbols: Strings = None, params={}) -> Tickers:
@@ -1277,14 +1323,7 @@ class bitfinex(Exchange, ImplicitAPI):
         #         ...
         #     ]
         #
-        result: dict = {}
-        for i in range(0, len(tickers)):
-            ticker = tickers[i]
-            marketId = self.safe_string(ticker, 0)
-            market = self.safe_market(marketId)
-            symbol = market['symbol']
-            result[symbol] = self.parse_ticker({'result': ticker}, market)
-        return self.filter_by_array_tickers(result, 'symbol', symbols)
+        return self.parse_tickers(tickers, symbols)
 
     def fetch_ticker(self, symbol: str, params={}) -> Ticker:
         """
@@ -1302,8 +1341,7 @@ class bitfinex(Exchange, ImplicitAPI):
             'symbol': market['id'],
         }
         ticker = self.publicGetTickerSymbol(self.extend(request, params))
-        result: dict = {'result': ticker}
-        return self.parse_ticker(result, market)
+        return self.parse_ticker(ticker, market)
 
     def parse_trade(self, trade: dict, market: Market = None) -> Trade:
         #

ccxt/bitget.py

@@ -1566,6 +1566,8 @@ class bitget(Exchange, ImplicitAPI):
                     'method': 'privateMixGetV2MixPositionAllPosition',  # or privateMixGetV2MixPositionHistoryPosition
                 },
                 'defaultTimeInForce': 'GTC',  # 'GTC' = Good To Cancel(default), 'IOC' = Immediate Or Cancel
+                # fiat currencies on deposit page
+                'fiatCurrencies': ['EUR', 'VND', 'PLN', 'CZK', 'HUF', 'DKK', 'AUD', 'CAD', 'NOK', 'SEK', 'CHF', 'MXN', 'COP', 'ARS', 'GBP', 'BRL', 'UAH', 'ZAR'],
             },
             'features': {
                 'spot': {
@@ -2024,99 +2026,85 @@ class bitget(Exchange, ImplicitAPI):
         """
         response = self.publicSpotGetV2SpotPublicCoins(params)
         #
-        #     {
-        #         "code": "00000",
-        #         "data": [
-        #             {
-        #                 "chains": [
-        #                     {
-        #                         "browserUrl": "https://blockchair.com/bitcoin/transaction/",
-        #                         "chain": "BTC",
-        #                         "depositConfirm": "1",
-        #                         "extraWithdrawFee": "0",
-        #                         "minDepositAmount": "0.0001",
-        #                         "minWithdrawAmount": "0.005",
-        #                         "needTag": "false",
-        #                         "rechargeable": "true",
-        #                         "withdrawConfirm": "1",
-        #                         "withdrawFee": "0.0004",
-        #                         "withdrawable": "true"
-        #                     },
-        #                 ],
-        #                 "coin": "BTC",
-        #                 "coinId": "1",
-        #                 "transfer": "true""
-        #             }
-        #         ],
-        #         "msg": "success",
-        #         "requestTime": "1700120731773"
-        #     }
+        #    {
+        #        "code": "00000",
+        #        "msg": "success",
+        #        "requestTime": "1746195617812",
+        #        "data": [
+        #            {
+        #                "coinId": "1456",
+        #                "coin": "NEIROETH",
+        #                "transfer": "false",
+        #                "chains": [
+        #                    {
+        #                        "chain": "ERC20",
+        #                        "needTag": "false",
+        #                        "withdrawable": "true",
+        #                        "rechargeable": "true",
+        #                        "withdrawFee": "44.91017965",
+        #                        "extraWithdrawFee": "0",
+        #                        "depositConfirm": "12",
+        #                        "withdrawConfirm": "64",
+        #                        "minDepositAmount": "0.06",
+        #                        "minWithdrawAmount": "60",
+        #                        "browserUrl": "https://etherscan.io/tx/",
+        #                        "contractAddress": "0xee2a03aa6dacf51c18679c516ad5283d8e7c2637",
+        #                        "withdrawStep": "0",
+        #                        "withdrawMinScale": "8",
+        #                        "congestion": "normal"
+        #                    }
+        #                ],
+        #                "areaCoin": "no"
+        #            },
+        #            ...
         #
         result: dict = {}
         data = self.safe_value(response, 'data', [])
+        fiatCurrencies = self.safe_list(self.options, 'fiatCurrencies', [])
         for i in range(0, len(data)):
             entry = data[i]
             id = self.safe_string(entry, 'coin')  # we don't use 'coinId' has no use. it is 'coin' field that needs to be used in currency related endpoints(deposit, withdraw, etc..)
             code = self.safe_currency_code(id)
             chains = self.safe_value(entry, 'chains', [])
             networks: dict = {}
-            deposit = False
-            withdraw = False
-            minWithdrawString = None
-            minDepositString = None
-            minWithdrawFeeString = None
             for j in range(0, len(chains)):
                 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()
-                withdrawEnabled = self.safe_string(chain, 'withdrawable')
-                canWithdraw = withdrawEnabled == 'true'
-                withdraw = canWithdraw if (canWithdraw) else withdraw
-                depositEnabled = self.safe_string(chain, 'rechargeable')
-                canDeposit = depositEnabled == 'true'
-                deposit = canDeposit if (canDeposit) else deposit
-                networkWithdrawFeeString = self.safe_string(chain, 'withdrawFee')
-                if networkWithdrawFeeString is not None:
-                    minWithdrawFeeString = networkWithdrawFeeString if (minWithdrawFeeString is None) else Precise.string_min(networkWithdrawFeeString, minWithdrawFeeString)
-                networkMinWithdrawString = self.safe_string(chain, 'minWithdrawAmount')
-                if networkMinWithdrawString is not None:
-                    minWithdrawString = networkMinWithdrawString if (minWithdrawString is None) else Precise.string_min(networkMinWithdrawString, minWithdrawString)
-                networkMinDepositString = self.safe_string(chain, 'minDepositAmount')
-                if networkMinDepositString is not None:
-                    minDepositString = networkMinDepositString if (minDepositString is None) else Precise.string_min(networkMinDepositString, minDepositString)
                 networks[network] = {
                     'info': chain,
                     'id': networkId,
                     'network': network,
                     'limits': {
                         'withdraw': {
-                            'min': self.parse_number(networkMinWithdrawString),
+                            'min': self.safe_number(chain, 'minWithdrawAmount'),
                             'max': None,
                         },
                         'deposit': {
-                            'min': self.parse_number(networkMinDepositString),
+                            'min': self.safe_number(chain, 'minDepositAmount'),
                             'max': None,
                         },
                     },
-                    'active': canWithdraw and canDeposit,
-                    'withdraw': canWithdraw,
-                    'deposit': canDeposit,
-                    'fee': self.parse_number(networkWithdrawFeeString),
-                    'precision': None,
+                    'active': None,
+                    'withdraw': self.safe_string(chain, 'withdrawable') == 'true',
+                    'deposit': self.safe_string(chain, 'rechargeable') == 'true',
+                    'fee': self.safe_number(chain, 'withdrawFee'),
+                    'precision': self.parse_number(self.parse_precision(self.safe_string(chain, 'withdrawMinScale'))),
                 }
-            result[code] = {
+            isFiat = self.in_array(code, fiatCurrencies)
+            result[code] = self.safe_currency_structure({
                 'info': entry,
                 'id': id,
                 'code': code,
                 'networks': networks,
-                'type': None,
+                'type': 'fiat' if isFiat else 'crypto',
                 'name': None,
-                'active': deposit and withdraw,
-                'deposit': deposit,
-                'withdraw': withdraw,
-                'fee': self.parse_number(minWithdrawFeeString),
+                'active': None,
+                'deposit': None,
+                'withdraw': None,
+                'fee': None,
                 'precision': None,
                 'limits': {
                     'amount': {
@@ -2124,16 +2112,16 @@ class bitget(Exchange, ImplicitAPI):
                         'max': None,
                     },
                     'withdraw': {
-                        'min': self.parse_number(minWithdrawString),
+                        'min': None,
                         'max': None,
                     },
                     'deposit': {
-                        'min': self.parse_number(minDepositString),
+                        'min': None,
                         'max': None,
                     },
                 },
                 'created': None,
-            }
+            })
         return result
 
     def fetch_market_leverage_tiers(self, symbol: str, params={}) -> List[LeverageTier]:
@@ -2752,7 +2740,7 @@ class bitget(Exchange, ImplicitAPI):
         close = self.safe_string(ticker, 'lastPr')
         timestamp = self.safe_integer_omit_zero(ticker, 'ts')  # exchange bitget provided 0
         change = self.safe_string(ticker, 'change24h')
-        open24 = self.safe_string(ticker, 'open24')
+        open24 = self.safe_string_2(ticker, 'open24', 'open24h')
         open = self.safe_string(ticker, 'open')
         symbol: str
         openValue: str
@@ -3419,6 +3407,7 @@ class bitget(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :param int [params.until]: timestamp in ms of the latest candle to fetch
         :param boolean [params.useHistoryEndpoint]: whether to force to use historical endpoint(it has max limit of 200)
+        :param boolean [params.useHistoryEndpointForPagination]: whether to force to use historical endpoint for pagination(default True)
         :param boolean [params.paginate]: default False, when True will automatically paginate by calling self endpoint multiple times. See in the docs all the [available parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
         :param str [params.price]: *swap only* "mark"(to fetch mark price candles) or "index"(to fetch index price candles)
         :returns int[][]: A list of candles ordered, open, high, low, close, volume
@@ -3427,11 +3416,13 @@ class bitget(Exchange, ImplicitAPI):
         defaultLimit = 100  # default 100, max 1000
         maxLimitForRecentEndpoint = 1000
         maxLimitForHistoryEndpoint = 200  # note, max 1000 bars are supported for "recent-candles" endpoint, but "historical-candles" support only max 200
+        useHistoryEndpoint = self.safe_bool(params, 'useHistoryEndpoint', False)
+        useHistoryEndpointForPagination = self.safe_bool(params, 'useHistoryEndpointForPagination', True)
         paginate = False
         paginate, params = self.handle_option_and_params(params, 'fetchOHLCV', 'paginate')
         if paginate:
-            return self.fetch_paginated_call_deterministic('fetchOHLCV', symbol, since, limit, timeframe, params, maxLimitForRecentEndpoint)
-        useHistoryEndpoint = self.safe_bool(params, 'useHistoryEndpoint', False)
+            limitForPagination = maxLimitForHistoryEndpoint if useHistoryEndpointForPagination else maxLimitForRecentEndpoint
+            return self.fetch_paginated_call_deterministic('fetchOHLCV', symbol, since, limit, timeframe, params, limitForPagination)
         market = self.market(symbol)
         marketType = 'spot' if market['spot'] else 'swap'
         timeframes = self.options['timeframes'][marketType]
@@ -4050,6 +4041,7 @@ class bitget(Exchange, ImplicitAPI):
         timestamp = self.safe_integer_2(order, 'cTime', 'ctime')
         updateTimestamp = self.safe_integer(order, 'uTime')
         rawStatus = self.safe_string_2(order, 'status', 'state')
+        rawStatus = self.safe_string(order, 'planStatus', rawStatus)
         fee = None
         feeCostString = self.safe_string(order, 'fee')
         if feeCostString is not None:

ccxt/bitmart.py

@@ -225,6 +225,7 @@ class bitmart(Exchange, ImplicitAPI):
                         'contract/private/order': 1.2,
                         'contract/private/order-history': 10,
                         'contract/private/position': 10,
+                        'contract/private/position-v2': 10,
                         'contract/private/get-open-orders': 1.2,
                         'contract/private/current-plan-order': 1.2,
                         'contract/private/trades': 10,
@@ -1214,6 +1215,7 @@ class bitmart(Exchange, ImplicitAPI):
         #                 {
         #                     "currency": "BTC",
         #                     "name": "Bitcoin",
+        #                     "recharge_minsize": '0.00000001',
         #                     "contract_address": null,
         #                     "network": "BTC",
         #                     "withdraw_enabled": True,
@@ -1235,7 +1237,8 @@ class bitmart(Exchange, ImplicitAPI):
             fullId = self.safe_string(currency, 'currency')
             currencyId = fullId
             networkId = self.safe_string(currency, 'network')
-            if fullId.find('NFT') < 0:
+            isNtf = (fullId.find('NFT') >= 0)
+            if not isNtf:
                 parts = fullId.split('-')
                 currencyId = self.safe_string(parts, 0)
                 second = self.safe_string(parts, 1)
@@ -1254,6 +1257,7 @@ class bitmart(Exchange, ImplicitAPI):
                     'withdraw': None,
                     'active': None,
                     'networks': {},
+                    'type': 'other' if isNtf else 'crypto',
                 }
             networkCode = self.network_id_to_code(networkId)
             withdraw = self.safe_bool(currency, 'withdraw_enabled')
@@ -4659,6 +4663,7 @@ class bitmart(Exchange, ImplicitAPI):
         fetch all open contract positions
 
         https://developer-pro.bitmart.com/en/futuresv2/#get-current-position-keyed
+        https://developer-pro.bitmart.com/en/futuresv2/#get-current-position-v2-keyed
 
         :param str[]|None symbols: list of unified market symbols
         :param dict [params]: extra parameters specific to the exchange API endpoint
@@ -4675,7 +4680,7 @@ class bitmart(Exchange, ImplicitAPI):
         if symbolsLength == 1:
             # only supports symbols or sending one symbol
             request['symbol'] = market['id']
-        response = self.privateGetContractPrivatePosition(self.extend(request, params))
+        response = self.privateGetContractPrivatePositionV2(self.extend(request, params))
         #
         #     {
         #         "code": 1000,

ccxt/bitmex.py

@@ -503,6 +503,7 @@ class bitmex(Exchange, ImplicitAPI):
             maxWithdrawal = self.parse_number(Precise.string_mul(maxWithdrawalString, precisionString))
             minDepositString = self.safe_string(currency, 'minDepositAmount')
             minDeposit = self.parse_number(Precise.string_mul(minDepositString, precisionString))
+            isCrypto = self.safe_string(currency, 'currencyType') == 'Crypto'
             result[code] = {
                 'id': id,
                 'code': code,
@@ -528,6 +529,7 @@ class bitmex(Exchange, ImplicitAPI):
                     },
                 },
                 'networks': networks,
+                'type': 'crypto' if isCrypto else 'other',
             }
         return result
 
@@ -756,6 +758,11 @@ class bitmex(Exchange, ImplicitAPI):
         maxOrderQty = self.safe_number(market, 'maxOrderQty')
         initMargin = self.safe_string(market, 'initMargin', '1')
         maxLeverage = self.parse_number(Precise.string_div('1', initMargin))
+        # subtype should be None for spot markets
+        if spot:
+            isInverse = None
+            isQuanto = None
+            linear = None
         return {
             'id': id,
             'symbol': symbol,
@@ -805,7 +812,7 @@ class bitmex(Exchange, ImplicitAPI):
                     'max': maxOrderQty if positionIsQuote else None,
                 },
             },
-            'created': self.parse8601(self.safe_string(market, 'listing')),
+            'created': None,  # 'listing' field is buggy, e.g. 2200-02-01T00:00:00.000Z
             'info': market,
         }
 

ccxt/bitopro.py

@@ -245,6 +245,7 @@ class bitopro(Exchange, ImplicitAPI):
                     'BEP20': 'BSC',
                     'BSC': 'BSC',
                 },
+                'fiatCurrencies': ['TWD'],  # the only fiat currency for exchange
             },
             'features': {
                 'spot': {
@@ -373,6 +374,7 @@ class bitopro(Exchange, ImplicitAPI):
         #     }
         #
         result: dict = {}
+        fiatCurrencies = self.safe_list(self.options, 'fiatCurrencies', [])
         for i in range(0, len(currencies)):
             currency = currencies[i]
             currencyId = self.safe_string(currency, 'currency')
@@ -392,11 +394,12 @@ class bitopro(Exchange, ImplicitAPI):
                     'max': None,
                 },
             }
+            isFiat = self.in_array(code, fiatCurrencies)
             result[code] = {
                 'id': currencyId,
                 'code': code,
                 'info': currency,
-                'type': None,
+                'type': 'fiat' if isFiat else 'crypto',
                 'name': None,
                 'active': deposit and withdraw,
                 'deposit': deposit,
@@ -404,6 +407,7 @@ class bitopro(Exchange, ImplicitAPI):
                 'fee': fee,
                 'precision': None,
                 'limits': limits,
+                'networks': None,
             }
         return result
 

ccxt/bitrue.py

@@ -833,7 +833,8 @@ class bitrue(Exchange, ImplicitAPI):
                 'withdraw': withdraw,
                 'networks': networks,
                 'fee': self.parse_number(minWithdrawFeeString),
-                # 'fees': fees,
+                'fees': None,
+                'type': 'crypto',
                 'limits': {
                     'withdraw': {
                         'min': self.parse_number(minWithdrawString),