ccxt 3.1.53__py2.py3-none-any.whl → 3.1.54__py2.py3-none-any.whl

ccxt/async_support/bitmex.py

@@ -57,10 +57,13 @@ class bitmex(Exchange, ImplicitAPI):
                 'editOrder': True,
                 'fetchBalance': True,
                 'fetchClosedOrders': True,
+                'fetchCurrencies': True,
                 'fetchDepositAddress': True,
                 'fetchDepositAddresses': False,
                 'fetchDepositAddressesByNetwork': False,
                 'fetchDepositsWithdrawals': 'emulated',
+                'fetchDepositWithdrawalFee': 'emulated',
+                'fetchDepositWithdrawalFees': True,
                 'fetchFundingHistory': False,
                 'fetchFundingRate': False,
                 'fetchFundingRateHistory': True,
@@ -235,32 +238,37 @@ class bitmex(Exchange, ImplicitAPI):
                 # https://github.com/ccxt/ccxt/issues/4789
                 'api-expires': 5,  # in seconds
                 'fetchOHLCVOpenTimestamp': True,
+                'oldPrecision': False,
                 'networks': {
                     'BTC': 'btc',
                     'ETH': 'eth',
-                    'BSC': 'bsc',
-                    'BNB': 'bsc',
-                    'TRON': 'tron',
                     'ERC20': 'eth',
                     'BEP20': 'bsc',
+                    'BSC': 'bsc',
                     'TRC20': 'tron',
+                    'TRON': 'tron',
                     'TRX': 'tron',
-                    'AVAX': 'avax',
+                    'AVALANCHEC': 'avax',
                     'NEAR': 'near',
+                    'TEZOS': 'xtz',
                     'XTZ': 'xtz',
+                    'POLKADOT': 'dot',
                     'DOT': 'dot',
+                    'SOLANA': 'sol',
                     'SOL': 'sol',
+                    'CARDANO': 'ada',
                 },
                 'networksById': {
                     'btc': 'BTC',
                     'eth': 'ERC20',
-                    'bsc': 'BSC',
-                    'tron': 'TRX',
-                    'avax': 'AVAX',
+                    'bsc': 'BEP20',
+                    'tron': 'TRC20',
+                    'avax': 'AVALANCHEC',
                     'near': 'NEAR',
-                    'xtz': 'XTZ',
-                    'dot': 'DOT',
-                    'sol': 'SOL',
+                    'xtz': 'TEZOS',
+                    'dot': 'POLKADOT',
+                    'sol': 'SOLANA',
+                    'ada': 'CARDANO',
                 },
             },
             'commonCurrencies': {
@@ -274,6 +282,166 @@ class bitmex(Exchange, ImplicitAPI):
             },
         })
 
+    async def fetch_currencies(self, params={}):
+        """
+        fetches all available currencies on an exchange
+        :param dict params: extra parameters specific to the mexc3 api endpoint
+        :returns dict: an associative dictionary of currencies
+        """
+        response = await self.publicGetWalletAssets(params)
+        #
+        #    {
+        #        "XBt": {
+        #            "asset": "XBT",
+        #            "currency": "XBt",
+        #            "majorCurrency": "XBT",
+        #            "name": "Bitcoin",
+        #            "currencyType": "Crypto",
+        #            "scale": "8",
+        #            # "mediumPrecision": "8",
+        #            # "shorterPrecision": "4",
+        #            # "symbol": "₿",
+        #            # "weight": "1",
+        #            # "tickLog": "0",
+        #            "enabled": True,
+        #            "isMarginCurrency": True,
+        #            "minDepositAmount": "10000",
+        #            "minWithdrawalAmount": "1000",
+        #            "maxWithdrawalAmount": "100000000000000",
+        #            "networks": [
+        #                {
+        #                    "asset": "btc",
+        #                    "tokenAddress": "",
+        #                    "depositEnabled": True,
+        #                    "withdrawalEnabled": True,
+        #                    "withdrawalFee": "20000",
+        #                    "minFee": "20000",
+        #                    "maxFee": "10000000"
+        #                }
+        #            ]
+        #        },
+        #     }
+        #
+        result = {}
+        for i in range(0, len(response)):
+            currency = response[i]
+            asset = self.safe_string(currency, 'asset')
+            code = self.safe_currency_code(asset)
+            id = self.safe_string(currency, 'currency')
+            name = self.safe_string(currency, 'name')
+            chains = self.safe_value(currency, 'networks', [])
+            depositEnabled = False
+            withdrawEnabled = False
+            networks = {}
+            scale = self.safe_string(currency, 'scale')
+            precisionString = self.parse_precision(scale)
+            precision = self.parse_number(precisionString)
+            for j in range(0, len(chains)):
+                chain = chains[j]
+                networkId = self.safe_string(chain, 'asset')
+                network = self.network_id_to_code(networkId)
+                withdrawalFeeRaw = self.safe_string(chain, 'withdrawalFee')
+                withdrawalFee = self.parse_number(Precise.string_mul(withdrawalFeeRaw, precisionString))
+                isDepositEnabled = self.safe_value(chain, 'depositEnabled', False)
+                isWithdrawEnabled = self.safe_value(chain, 'withdrawalEnabled', False)
+                active = (isDepositEnabled and isWithdrawEnabled)
+                if isDepositEnabled:
+                    depositEnabled = True
+                if isWithdrawEnabled:
+                    withdrawEnabled = True
+                networks[network] = {
+                    'info': chain,
+                    'id': networkId,
+                    'network': network,
+                    'active': active,
+                    'deposit': isDepositEnabled,
+                    'withdraw': isWithdrawEnabled,
+                    'fee': withdrawalFee,
+                    'precision': None,
+                    'limits': {
+                        'withdraw': {
+                            'min': None,
+                            'max': None,
+                        },
+                        'deposit': {
+                            'min': None,
+                            'max': None,
+                        },
+                    },
+                }
+            currencyEnabled = self.safe_value(currency, 'enabled')
+            currencyActive = currencyEnabled or (depositEnabled or withdrawEnabled)
+            minWithdrawalString = self.safe_string(currency, 'minWithdrawalAmount')
+            minWithdrawal = self.parse_number(Precise.string_mul(minWithdrawalString, precisionString))
+            maxWithdrawalString = self.safe_string(currency, 'maxWithdrawalAmount')
+            maxWithdrawal = self.parse_number(Precise.string_mul(maxWithdrawalString, precisionString))
+            minDepositString = self.safe_string(currency, 'minDepositAmount')
+            minDeposit = self.parse_number(Precise.string_mul(minDepositString, precisionString))
+            result[code] = {
+                'id': id,
+                'code': code,
+                'info': currency,
+                'name': name,
+                'active': currencyActive,
+                'deposit': depositEnabled,
+                'withdraw': withdrawEnabled,
+                'fee': None,
+                'precision': precision,
+                'limits': {
+                    'amount': {
+                        'min': None,
+                        'max': None,
+                    },
+                    'withdraw': {
+                        'min': minWithdrawal,
+                        'max': maxWithdrawal,
+                    },
+                    'deposit': {
+                        'min': minDeposit,
+                        'max': None,
+                    },
+                },
+                'networks': networks,
+            }
+        return result
+
+    def convert_from_real_amount(self, code, amount):
+        currency = self.currency(code)
+        precision = self.safe_string(currency, 'precision')
+        amountString = self.number_to_string(amount)
+        finalAmount = Precise.string_div(amountString, precision)
+        return self.parse_number(finalAmount)
+
+    def convert_to_real_amount(self, code, amount):
+        currency = self.currency(code)
+        precision = self.safe_string(currency, 'precision')
+        amountString = self.number_to_string(amount)
+        finalAmount = Precise.string_mul(amountString, precision)
+        return self.parse_number(finalAmount)
+
+    def amount_to_precision(self, symbol, amount):
+        symbol = self.safe_symbol(symbol)
+        market = self.market(symbol)
+        oldPrecision = self.safe_value(self.options, 'oldPrecision')
+        if market['spot'] and not oldPrecision:
+            amount = self.convert_from_real_amount(market['base'], amount)
+        return super(bitmex, self).amount_to_precision(symbol, amount)
+
+    def convert_from_raw_quantity(self, symbol, rawQuantity, currencySide='base'):
+        if self.safe_value(self.options, 'oldPrecision'):
+            return self.parse_number(rawQuantity)
+        symbol = self.safe_symbol(symbol)
+        marketExists = self.in_array(symbol, self.symbols)
+        if not marketExists:
+            return self.parse_number(rawQuantity)
+        market = self.market(symbol)
+        if market['spot']:
+            return self.convert_to_real_amount(market[currencySide], rawQuantity)
+        return self.parse_number(rawQuantity)
+
+    def convert_from_raw_cost(self, symbol, rawQuantity):
+        return self.convert_from_raw_quantity(symbol, rawQuantity, 'quote')
+
     async def fetch_markets(self, params={}):
         """
         retrieves data on all markets for bitmex
@@ -404,102 +572,109 @@ class bitmex(Exchange, ImplicitAPI):
             settle = self.safe_currency_code(settleId)
             # 'positionCurrency' may be empty("", currently returns for ETHUSD)
             # so let's take the settlCurrency first and then adjust if needed
-            typ = self.safe_string(market, 'typ')
-            # Perpetual Contracts - FFWCSX
-            # Perpetual Contracts(FX underliers) - FFWCSF
-            # Spot - IFXXXP
-            # Futures - FFCCSX
-            # BitMEX Basket Index - MRBXXX
-            # BitMEX Crypto Index - MRCXXX
-            # BitMEX FX Index - MRFXXX
-            # BitMEX Lending/Premium Index - MRRXXX
-            # BitMEX Volatility Index - MRIXXX
+            typ = self.safe_string(market, 'typ')  # type definitions at: https://www.bitmex.com/api/explorer/#not /Instrument/Instrument_get
             types = {
                 'FFWCSX': 'swap',
                 'FFWCSF': 'swap',
                 'IFXXXP': 'spot',
                 'FFCCSX': 'future',
+                'MRBXXX': 'index',
+                'MRCXXX': 'index',
+                'MRFXXX': 'index',
+                'MRRXXX': 'index',
+                'MRIXXX': 'index',
             }
             type = self.safe_string(types, typ, typ)
             swap = type == 'swap'
             future = type == 'future'
             spot = type == 'spot'
             contract = swap or future
-            symbol = base + '/' + quote
             contractSize = None
-            if contract:
-                symbol = symbol + ':' + settle
-                multiplierString = Precise.string_abs(self.safe_string(market, 'multiplier'))
-                contractSize = self.parse_number(multiplierString)
-            inverse = self.safe_value(market, 'isInverse')
+            index = type == 'index'
+            isInverse = self.safe_value(market, 'isInverse')  # self is True when BASE and SETTLE are same, i.e. BTC/XXX:BTC
+            isQuanto = self.safe_value(market, 'isQuanto')  # self is True when BASE and SETTLE are different, i.e. AXS/XXX:BTC
+            linear = (not isInverse and not isQuanto) if contract else None
             status = self.safe_string(market, 'state')
             active = status != 'Unlisted'
             expiry = None
             expiryDatetime = None
-            if future:
-                expiryDatetime = self.safe_string(market, 'expiry')
-                expiry = self.parse8601(expiryDatetime)
-                symbol = symbol + '-' + self.yymmdd(expiry)
+            symbol = None
+            if spot:
+                symbol = base + '/' + quote
+            elif contract:
+                symbol = base + '/' + quote + ':' + settle
+                multiplierString = Precise.string_abs(self.safe_string(market, 'multiplier'))
+                if linear:
+                    contractSize = self.parse_number(Precise.string_div('1', market['underlyingToPositionMultiplier']))
+                else:
+                    contractSize = self.parse_number(multiplierString)
+                if future:
+                    expiryDatetime = self.safe_string(market, 'expiry')
+                    expiry = self.parse8601(expiryDatetime)
+                    symbol = symbol + '-' + self.yymmdd(expiry)
+            else:
+                # for index/exotic markets, default to id
+                symbol = id
             positionId = self.safe_string_2(market, 'positionCurrency', 'underlying')
             position = self.safe_currency_code(positionId)
             positionIsQuote = (position == quote)
             maxOrderQty = self.safe_number(market, 'maxOrderQty')
             initMargin = self.safe_string(market, 'initMargin', '1')
             maxLeverage = self.parse_number(Precise.string_div('1', initMargin))
-            # temporarily filter out unlisted markets to avoid symbol conflicts
-            if active:
-                result.append({
-                    'id': id,
-                    'symbol': symbol,
-                    'base': base,
-                    'quote': quote,
-                    'settle': settle,
-                    'baseId': baseId,
-                    'quoteId': quoteId,
-                    'settleId': settleId,
-                    'type': type,
-                    'spot': spot,
-                    'margin': False,
-                    'swap': swap,
-                    'future': future,
-                    'option': False,
-                    'active': active,
-                    'contract': contract,
-                    'linear': not inverse if contract else None,
-                    'inverse': inverse if contract else None,
-                    'taker': self.safe_number(market, 'takerFee'),
-                    'maker': self.safe_number(market, 'makerFee'),
-                    'contractSize': contractSize,
-                    'expiry': expiry,
-                    'expiryDatetime': expiryDatetime,
-                    'strike': self.safe_number(market, 'optionStrikePrice'),
-                    'optionType': None,
-                    'precision': {
-                        'amount': self.safe_number(market, 'lotSize'),
-                        'price': self.safe_number(market, 'tickSize'),
-                        'quote': self.safe_number(market, 'tickSize'),
-                        'base': self.safe_number(market, 'tickSize'),
+            result.append({
+                'id': id,
+                'symbol': symbol,
+                'base': base,
+                'quote': quote,
+                'settle': settle,
+                'baseId': baseId,
+                'quoteId': quoteId,
+                'settleId': settleId,
+                'type': type,
+                'spot': spot,
+                'margin': False,
+                'swap': swap,
+                'future': future,
+                'option': False,
+                'index': index,
+                'active': active,
+                'contract': contract,
+                'linear': linear,
+                'inverse': isInverse,
+                'quanto': isQuanto,
+                'taker': self.safe_number(market, 'takerFee'),
+                'maker': self.safe_number(market, 'makerFee'),
+                'contractSize': contractSize,
+                'expiry': expiry,
+                'expiryDatetime': expiryDatetime,
+                'strike': self.safe_number(market, 'optionStrikePrice'),
+                'optionType': None,
+                'precision': {
+                    'amount': self.safe_number(market, 'lotSize'),
+                    'price': self.safe_number(market, 'tickSize'),
+                    'quote': self.safe_number(market, 'tickSize'),
+                    'base': self.safe_number(market, 'tickSize'),
+                },
+                'limits': {
+                    'leverage': {
+                        'min': self.parse_number('1') if contract else None,
+                        'max': maxLeverage if contract else None,
                     },
-                    'limits': {
-                        'leverage': {
-                            'min': self.parse_number('1') if contract else None,
-                            'max': maxLeverage if contract else None,
-                        },
-                        'amount': {
-                            'min': None,
-                            'max': None if positionIsQuote else maxOrderQty,
-                        },
-                        'price': {
-                            'min': None,
-                            'max': self.safe_number(market, 'maxPrice'),
-                        },
-                        'cost': {
-                            'min': None,
-                            'max': maxOrderQty if positionIsQuote else None,
-                        },
+                    'amount': {
+                        'min': None,
+                        'max': None if positionIsQuote else maxOrderQty,
+                    },
+                    'price': {
+                        'min': None,
+                        'max': self.safe_number(market, 'maxPrice'),
                     },
-                    'info': market,
-                })
+                    'cost': {
+                        'min': None,
+                        'max': maxOrderQty if positionIsQuote else None,
+                    },
+                },
+                'info': market,
+            })
         return result
 
     def parse_balance(self, response):
@@ -558,24 +733,8 @@ class bitmex(Exchange, ImplicitAPI):
             account = self.account()
             free = self.safe_string(balance, 'availableMargin')
             total = self.safe_string(balance, 'marginBalance')
-            if code != 'USDT':
-                # tmp fix until self PR gets merged
-                # https://github.com/ccxt/ccxt/pull/15311
-                symbol = code + '_USDT'
-                market = self.safe_market(symbol)
-                info = self.safe_value(market, 'info', {})
-                multiplier = self.safe_string(info, 'underlyingToPositionMultiplier')
-                if multiplier is not None:
-                    free = Precise.string_div(free, multiplier)
-                    total = Precise.string_div(total, multiplier)
-                else:
-                    free = Precise.string_div(free, '1e8')
-                    total = Precise.string_div(total, '1e8')
-            else:
-                free = Precise.string_div(free, '1e6')
-                total = Precise.string_div(total, '1e6')
-            account['free'] = free
-            account['total'] = total
+            account['free'] = self.convert_to_real_amount(code, free)
+            account['total'] = self.convert_to_real_amount(code, total)
             result[code] = account
         return self.safe_balance(result)
 
@@ -666,7 +825,7 @@ class bitmex(Exchange, ImplicitAPI):
         for i in range(0, len(response)):
             order = response[i]
             side = 'asks' if (order['side'] == 'Sell') else 'bids'
-            amount = self.safe_number(order, 'size')
+            amount = self.convert_from_raw_quantity(symbol, self.safe_string(order, 'size'))
             price = self.safe_number(order, 'price')
             # https://github.com/ccxt/ccxt/issues/4926
             # https://github.com/ccxt/ccxt/issues/4927
@@ -893,9 +1052,8 @@ class bitmex(Exchange, ImplicitAPI):
         type = self.parse_ledger_entry_type(self.safe_string(item, 'transactType'))
         currencyId = self.safe_string(item, 'currency')
         code = self.safe_currency_code(currencyId, currency)
-        amount = self.safe_number(item, 'amount')
-        if amount is not None:
-            amount = amount / 100000000
+        amountString = self.safe_string(item, 'amount')
+        amount = self.convert_to_real_amount(code, amountString)
         timestamp = self.parse8601(self.safe_string(item, 'transactTime'))
         if timestamp is None:
             # https://github.com/ccxt/ccxt/issues/6047
@@ -904,19 +1062,19 @@ class bitmex(Exchange, ImplicitAPI):
             timestamp = 0  # see comments above
         feeCost = self.safe_number(item, 'fee', 0)
         if feeCost is not None:
-            feeCost = feeCost / 100000000
+            feeCost = self.convert_to_real_amount(code, feeCost)
         fee = {
             'cost': feeCost,
             'currency': code,
         }
         after = self.safe_number(item, 'walletBalance')
         if after is not None:
-            after = after / 100000000
-        before = self.sum(after, -amount)
+            after = self.convert_to_real_amount(code, after)
+        before = self.parse_number(Precise.string_sub(self.number_to_string(after), self.number_to_string(amount)))
         direction = None
-        if amount < 0:
+        if Precise.string_lt(amountString, '0'):
             direction = 'out'
-            amount = abs(amount)
+            amount = self.convert_to_real_amount(code, Precise.string_abs(amountString))
         else:
             direction = 'in'
         status = self.parse_transaction_status(self.safe_string(item, 'transactStatus'))
@@ -948,9 +1106,6 @@ class bitmex(Exchange, ImplicitAPI):
         :returns dict: a `ledger structure <https://docs.ccxt.com/#/?id=ledger-structure>`
         """
         await self.load_markets()
-        currency = None
-        if code is not None:
-            currency = self.currency(code)
         request = {
             # 'start': 123,
         }
@@ -961,6 +1116,10 @@ class bitmex(Exchange, ImplicitAPI):
         #
         if limit is not None:
             request['count'] = limit
+        currency = None
+        if code is not None:
+            currency = self.currency(code)
+            request['currency'] = currency['id']
         response = await self.privateGetUserWalletHistory(self.extend(request, params))
         #
         #     [
@@ -1003,13 +1162,14 @@ class bitmex(Exchange, ImplicitAPI):
         #         # date-based pagination not supported
         #     }
         #
+        currency = None
+        if code is not None:
+            currency = self.currency(code)
+            request['currency'] = currency['id']
         if limit is not None:
             request['count'] = limit
         response = await self.privateGetUserWalletHistory(self.extend(request, params))
         transactions = self.filter_by_array(response, 'transactType', ['Withdrawal', 'Deposit'], False)
-        currency = None
-        if code is not None:
-            currency = self.currency(code)
         return self.parse_transactions(transactions, currency, since, limit)
 
     def parse_transaction_status(self, status):
@@ -1059,10 +1219,9 @@ class bitmex(Exchange, ImplicitAPI):
             addressTo = self.safe_string(transaction, 'address')
             addressFrom = self.safe_string(transaction, 'tx')
         amountString = self.safe_string(transaction, 'amount')
-        scale = '1e8' if (currency['code'] == 'BTC') else '1e6'
-        amountString = Precise.string_div(Precise.string_abs(amountString), scale)
+        amount = self.convert_to_real_amount(currency['code'], amountString)
         feeCostString = self.safe_string(transaction, 'fee')
-        feeCostString = Precise.string_div(feeCostString, scale)
+        feeCost = self.convert_to_real_amount(currency['code'], feeCostString)
         status = self.safe_string(transaction, 'transactStatus')
         if status is not None:
             status = self.parse_transaction_status(status)
@@ -1073,7 +1232,7 @@ class bitmex(Exchange, ImplicitAPI):
             'type': type,
             'currency': currency['code'],
             'network': self.safe_string(transaction, 'network'),
-            'amount': self.parse_number(amountString),
+            'amount': amount,
             'status': status,
             'timestamp': transactTime,
             'datetime': self.iso8601(transactTime),
@@ -1087,7 +1246,7 @@ class bitmex(Exchange, ImplicitAPI):
             'comment': None,
             'fee': {
                 'currency': currency['code'],
-                'cost': self.parse_number(feeCostString),
+                'cost': feeCost,
                 'rate': None,
             },
         }
@@ -1130,112 +1289,7 @@ class bitmex(Exchange, ImplicitAPI):
         return self.filter_by_array(result, 'symbol', symbols)
 
     def parse_ticker(self, ticker, market=None):
-        #
-        #     {                        symbol: "ETHH19",
-        #                           rootSymbol: "ETH",
-        #                                state: "Open",
-        #                                  typ: "FFCCSX",
-        #                              listing: "2018-12-17T04:00:00.000Z",
-        #                                front: "2019-02-22T12:00:00.000Z",
-        #                               expiry: "2019-03-29T12:00:00.000Z",
-        #                               settle: "2019-03-29T12:00:00.000Z",
-        #                       relistInterval:  null,
-        #                           inverseLeg: "",
-        #                              sellLeg: "",
-        #                               buyLeg: "",
-        #                     optionStrikePcnt:  null,
-        #                    optionStrikeRound:  null,
-        #                    optionStrikePrice:  null,
-        #                     optionMultiplier:  null,
-        #                     positionCurrency: "ETH",
-        #                           underlying: "ETH",
-        #                        quoteCurrency: "XBT",
-        #                     underlyingSymbol: "ETHXBT=",
-        #                            reference: "BMEX",
-        #                      referenceSymbol: ".BETHXBT30M",
-        #                         calcInterval:  null,
-        #                      publishInterval:  null,
-        #                          publishTime:  null,
-        #                          maxOrderQty:  100000000,
-        #                             maxPrice:  10,
-        #                              lotSize:  1,
-        #                             tickSize:  0.00001,
-        #                           multiplier:  100000000,
-        #                        settlCurrency: "XBt",
-        #       underlyingToPositionMultiplier:  1,
-        #         underlyingToSettleMultiplier:  null,
-        #              quoteToSettleMultiplier:  100000000,
-        #                             isQuanto:  False,
-        #                            isInverse:  False,
-        #                           initMargin:  0.02,
-        #                          maintMargin:  0.01,
-        #                            riskLimit:  5000000000,
-        #                             riskStep:  5000000000,
-        #                                limit:  null,
-        #                               capped:  False,
-        #                                taxed:  True,
-        #                           deleverage:  True,
-        #                             makerFee:  -0.0005,
-        #                             takerFee:  0.0025,
-        #                        settlementFee:  0,
-        #                         insuranceFee:  0,
-        #                    fundingBaseSymbol: "",
-        #                   fundingQuoteSymbol: "",
-        #                 fundingPremiumSymbol: "",
-        #                     fundingTimestamp:  null,
-        #                      fundingInterval:  null,
-        #                          fundingRate:  null,
-        #                indicativeFundingRate:  null,
-        #                   rebalanceTimestamp:  null,
-        #                    rebalanceInterval:  null,
-        #                     openingTimestamp: "2019-02-13T08:00:00.000Z",
-        #                     closingTimestamp: "2019-02-13T09:00:00.000Z",
-        #                      sessionInterval: "2000-01-01T01:00:00.000Z",
-        #                       prevClosePrice:  0.03347,
-        #                       limitDownPrice:  null,
-        #                         limitUpPrice:  null,
-        #               bankruptLimitDownPrice:  null,
-        #                 bankruptLimitUpPrice:  null,
-        #                      prevTotalVolume:  1386531,
-        #                          totalVolume:  1387062,
-        #                               volume:  531,
-        #                            volume24h:  17118,
-        #                    prevTotalTurnover:  4741294246000,
-        #                        totalTurnover:  4743103466000,
-        #                             turnover:  1809220000,
-        #                          turnover24h:  57919845000,
-        #                      homeNotional24h:  17118,
-        #                   foreignNotional24h:  579.19845,
-        #                         prevPrice24h:  0.03349,
-        #                                 vwap:  0.03383564,
-        #                            highPrice:  0.03458,
-        #                             lowPrice:  0.03329,
-        #                            lastPrice:  0.03406,
-        #                   lastPriceProtected:  0.03406,
-        #                    lastTickDirection: "ZeroMinusTick",
-        #                       lastChangePcnt:  0.017,
-        #                             bidPrice:  0.03406,
-        #                             midPrice:  0.034065,
-        #                             askPrice:  0.03407,
-        #                       impactBidPrice:  0.03406,
-        #                       impactMidPrice:  0.034065,
-        #                       impactAskPrice:  0.03407,
-        #                         hasLiquidity:  True,
-        #                         openInterest:  83679,
-        #                            openValue:  285010674000,
-        #                           fairMethod: "ImpactMidPrice",
-        #                        fairBasisRate:  0,
-        #                            fairBasis:  0,
-        #                            fairPrice:  0.03406,
-        #                           markMethod: "FairPrice",
-        #                            markPrice:  0.03406,
-        #                    indicativeTaxRate:  0,
-        #                indicativeSettlePrice:  0.03406,
-        #                optionUnderlyingPrice:  null,
-        #                         settledPrice:  null,
-        #                            timestamp: "2019-02-13T08:40:30.000Z",
-        #     }
-        #
+        # see response sample under "fetchMarkets" because same endpoint is being used here
         marketId = self.safe_string(ticker, 'symbol')
         symbol = self.safe_symbol(marketId, market)
         timestamp = self.parse8601(self.safe_string(ticker, 'timestamp'))
@@ -1259,8 +1313,8 @@ class bitmex(Exchange, ImplicitAPI):
             'change': None,
             'percentage': None,
             'average': None,
-            'baseVolume': self.safe_string(ticker, 'homeNotional24h'),
-            'quoteVolume': self.safe_string(ticker, 'foreignNotional24h'),
+            'baseVolume': self.convert_from_raw_quantity(symbol, self.safe_string(ticker, 'homeNotional24h')),
+            'quoteVolume': self.convert_from_raw_quantity(symbol, self.safe_string(ticker, 'foreignNotional24h')),
             'info': ticker,
         }, market)
 
@@ -1282,13 +1336,16 @@ class bitmex(Exchange, ImplicitAPI):
         #         "foreignNotional":0
         #     }
         #
+        marketId = self.safe_string(ohlcv, 'symbol')
+        market = self.safe_market(marketId, market)
+        volume = self.convert_from_raw_quantity(market['symbol'], self.safe_string(ohlcv, 'volume'))
         return [
             self.parse8601(self.safe_string(ohlcv, 'timestamp')),
             self.safe_number(ohlcv, 'open'),
             self.safe_number(ohlcv, 'high'),
             self.safe_number(ohlcv, 'low'),
             self.safe_number(ohlcv, 'close'),
-            self.safe_number(ohlcv, 'volume'),
+            volume,
         ]
 
     async def fetch_ohlcv(self, symbol: str, timeframe='1m', since: Optional[int] = None, limit: Optional[int] = None, params={}):
@@ -1418,17 +1475,18 @@ class bitmex(Exchange, ImplicitAPI):
         #         "timestamp": "2019-03-05T12:47:02.762Z"
         #     }
         #
+        marketId = self.safe_string(trade, 'symbol')
+        symbol = self.safe_symbol(marketId, market)
         timestamp = self.parse8601(self.safe_string(trade, 'timestamp'))
         priceString = self.safe_string_2(trade, 'avgPx', 'price')
-        amountString = self.safe_string_2(trade, 'size', 'lastQty')
-        execCost = self.safe_string(trade, 'execCost')
-        costString = Precise.string_div(Precise.string_abs(execCost), '1e8')
+        amountString = self.convert_from_raw_quantity(symbol, self.safe_string_2(trade, 'size', 'lastQty'))
+        execCost = self.number_to_string(self.convert_from_raw_cost(symbol, self.safe_string(trade, 'execCost')))
         id = self.safe_string(trade, 'trdMatchID')
         order = self.safe_string(trade, 'orderID')
         side = self.safe_string_lower(trade, 'side')
         # price * amount doesn't work for all symbols(e.g. XBT, ETH)
         fee = None
-        feeCostString = Precise.string_div(self.safe_string(trade, 'execComm'), '1e8')
+        feeCostString = self.number_to_string(self.convert_from_raw_cost(symbol, self.safe_string(trade, 'execComm')))
         if feeCostString is not None:
             currencyId = self.safe_string(trade, 'settlCurrency')
             feeCurrencyCode = self.safe_currency_code(currencyId)
@@ -1443,8 +1501,6 @@ class bitmex(Exchange, ImplicitAPI):
         takerOrMaker = None
         if feeCostString is not None and execType == 'Trade':
             takerOrMaker = 'maker' if Precise.string_lt(feeCostString, '0') else 'taker'
-        marketId = self.safe_string(trade, 'symbol')
-        symbol = self.safe_symbol(marketId, market)
         type = self.safe_string_lower(trade, 'ordType')
         return self.safe_trade({
             'info': trade,
@@ -1457,7 +1513,7 @@ class bitmex(Exchange, ImplicitAPI):
             'takerOrMaker': takerOrMaker,
             'side': side,
             'price': priceString,
-            'cost': costString,
+            'cost': Precise.string_abs(execCost),
             'amount': amountString,
             'fee': fee,
         }, market)
@@ -1532,9 +1588,26 @@ class bitmex(Exchange, ImplicitAPI):
         timestamp = self.parse8601(self.safe_string(order, 'timestamp'))
         lastTradeTimestamp = self.parse8601(self.safe_string(order, 'transactTime'))
         price = self.safe_string(order, 'price')
-        amount = self.safe_string(order, 'orderQty')
-        filled = self.safe_string(order, 'cumQty')
+        qty = self.safe_string(order, 'orderQty')
+        cost = None
+        amount = None
+        defaultSubType = self.safe_string(self.options, 'defaultSubType', 'linear')
+        isInverse = False
+        if market is None:
+            isInverse = (defaultSubType == 'inverse')
+        else:
+            isInverse = self.safe_value(market, 'inverse', False)
+        if isInverse:
+            cost = self.convert_from_raw_quantity(symbol, qty)
+        else:
+            amount = self.convert_from_raw_quantity(symbol, qty)
         average = self.safe_string(order, 'avgPx')
+        filled = None
+        cumQty = self.number_to_string(self.convert_from_raw_quantity(symbol, self.safe_string(order, 'cumQty')))
+        if isInverse:
+            filled = Precise.string_div(cumQty, average)
+        else:
+            filled = cumQty
         id = self.safe_string(order, 'orderID')
         type = self.safe_string_lower(order, 'ordType')
         side = self.safe_string_lower(order, 'side')
@@ -1561,7 +1634,7 @@ class bitmex(Exchange, ImplicitAPI):
             'stopPrice': stopPrice,
             'triggerPrice': stopPrice,
             'amount': amount,
-            'cost': None,
+            'cost': cost,
             'average': average,
             'filled': filled,
             'remaining': None,
@@ -1641,10 +1714,11 @@ class bitmex(Exchange, ImplicitAPI):
             if (market['type'] != 'swap') and (market['type'] != 'future'):
                 raise InvalidOrder(self.id + ' createOrder() does not support reduceOnly for ' + market['type'] + ' orders, reduceOnly orders are supported for swap and future markets only')
         brokerId = self.safe_string(self.options, 'brokerId', 'CCXT')
+        qty = self.parse_to_int(self.amount_to_precision(symbol, amount))
         request = {
             'symbol': market['id'],
             'side': self.capitalize(side),
-            'orderQty': float(self.amount_to_precision(symbol, amount)),  # lot size multiplied by the number of contracts
+            'orderQty': qty,  # lot size multiplied by the number of contracts
             'ordType': orderType,
             'text': brokerId,
         }
@@ -1677,7 +1751,8 @@ class bitmex(Exchange, ImplicitAPI):
         else:
             request['orderID'] = id
         if amount is not None:
-            request['orderQty'] = amount
+            qty = self.parse_to_int(self.amount_to_precision(symbol, amount))
+            request['orderQty'] = qty
         if price is not None:
             request['price'] = price
         brokerId = self.safe_string(self.options, 'brokerId', 'CCXT')
@@ -1995,14 +2070,19 @@ class bitmex(Exchange, ImplicitAPI):
         datetime = self.safe_string(position, 'timestamp')
         crossMargin = self.safe_value(position, 'crossMargin')
         marginMode = 'cross' if (crossMargin is True) else 'isolated'
-        notional = None
-        if market['quote'] == 'USDT' or market['quote'] == 'USD' or market['quote'] == 'EUR':
-            notional = Precise.string_mul(self.safe_string(position, 'foreignNotional'), '-1')
-        else:
-            notional = self.safe_string(position, 'homeNotional')
-        maintenanceMargin = self.safe_number(position, 'maintMargin')
-        unrealisedPnl = self.safe_number(position, 'unrealisedPnl')
-        contracts = self.omit_zero(self.safe_number(position, 'currentQty'))
+        notionalString = Precise.string_abs(self.safe_string(position, 'foreignNotional', 'homeNotional'))
+        settleCurrencyCode = self.safe_string(market, 'settle')
+        maintenanceMargin = self.convert_to_real_amount(settleCurrencyCode, self.safe_string(position, 'maintMargin'))
+        unrealisedPnl = self.convert_to_real_amount(settleCurrencyCode, self.safe_string(position, 'unrealisedPnl'))
+        contracts = self.parse_number(Precise.string_abs(self.safe_string(position, 'currentQty')))
+        contractSize = self.safe_number(market, 'contractSize')
+        side = None
+        homeNotional = self.safe_string(position, 'homeNotional')
+        if homeNotional is not None:
+            if homeNotional[0] == '-':
+                side = 'short'
+            else:
+                side = 'long'
         return self.safe_position({
             'info': position,
             'id': self.safe_string(position, 'account'),
@@ -2011,52 +2091,26 @@ class bitmex(Exchange, ImplicitAPI):
             'datetime': datetime,
             'lastUpdateTimestamp': None,
             'hedged': None,
-            'side': None,
-            'contracts': self.convert_value(contracts, market),
-            'contractSize': None,
+            'side': side,
+            'contracts': contracts,
+            'contractSize': contractSize,
             'entryPrice': self.safe_number(position, 'avgEntryPrice'),
             'markPrice': self.safe_number(position, 'markPrice'),
             'lastPrice': None,
-            'notional': notional,
+            'notional': self.parse_number(notionalString),
             'leverage': self.safe_number(position, 'leverage'),
             'collateral': None,
             'initialMargin': self.safe_number(position, 'initMargin'),
             'initialMarginPercentage': self.safe_number(position, 'initMarginReq'),
-            'maintenanceMargin': self.convert_value(maintenanceMargin, market),
+            'maintenanceMargin': maintenanceMargin,
             'maintenanceMarginPercentage': self.safe_number(position, 'maintMarginReq'),
-            'unrealizedPnl': self.convert_value(unrealisedPnl, market),
+            'unrealizedPnl': unrealisedPnl,
             'liquidationPrice': self.safe_number(position, 'liquidationPrice'),
             'marginMode': marginMode,
             'marginRatio': None,
             'percentage': self.safe_number(position, 'unrealisedPnlPcnt'),
         })
 
-    def convert_value(self, value, market=None):
-        if (value is None) or (market is None):
-            return value
-        resultValue = None
-        value = self.number_to_string(value)
-        if (market['quote'] == 'USD') or (market['quote'] == 'EUR'):
-            resultValue = Precise.string_mul(value, '0.00000001')
-        elif market['quote'] == 'USDT':
-            resultValue = Precise.string_mul(value, '0.000001')
-        else:
-            currency = None
-            quote = market['quote']
-            if quote is not None:
-                currency = self.currency(market['quote'])
-            if currency is not None:
-                resultValue = Precise.string_mul(value, self.number_to_string(currency['precision']))
-        resultValue = float(resultValue) if (resultValue is not None) else None
-        return resultValue
-
-    def is_fiat(self, currency):
-        if currency == 'EUR':
-            return True
-        if currency == 'PLN':
-            return True
-        return False
-
     async def withdraw(self, code: str, amount, address, tag=None, params={}):
         """
         make a withdrawal
@@ -2070,14 +2124,15 @@ class bitmex(Exchange, ImplicitAPI):
         tag, params = self.handle_withdraw_tag_and_params(tag, params)
         self.check_address(address)
         await self.load_markets()
-        # currency = self.currency(code)
-        if code != 'BTC':
-            raise ExchangeError(self.id + ' supoprts BTC withdrawals only, other currencies coming soon...')
         currency = self.currency(code)
+        qty = self.convert_from_real_amount(code, amount)
+        networkCode = None
+        networkCode, params = self.handle_network_code_and_params(params)
         request = {
-            'currency': 'XBt',  # temporarily
-            'amount': amount,
+            'currency': currency['id'],
+            'amount': qty,
             'address': address,
+            'network': self.network_code_to_id(networkCode, currency['code']),
             # 'otpToken': '123456',  # requires if two-factor auth(OTP) is enabled
             # 'fee': 0.001,  # bitcoin network fee
         }
@@ -2122,115 +2177,7 @@ class bitmex(Exchange, ImplicitAPI):
         return self.parse_funding_rates(filteredResponse, symbols)
 
     def parse_funding_rate(self, contract, market=None):
-        #
-        #    {
-        #        "symbol": "LTCUSDT",
-        #        "rootSymbol": "LTC",
-        #        "state": "Open",
-        #        "typ": "FFWCSX",
-        #        "listing": "2021-11-10T04:00:00.000Z",
-        #        "front": "2021-11-10T04:00:00.000Z",
-        #        "expiry": null,
-        #        "settle": null,
-        #        "listedSettle": null,
-        #        "relistInterval": null,
-        #        "inverseLeg": "",
-        #        "sellLeg": "",
-        #        "buyLeg": "",
-        #        "optionStrikePcnt": null,
-        #        "optionStrikeRound": null,
-        #        "optionStrikePrice": null,
-        #        "optionMultiplier": null,
-        #        "positionCurrency": "LTC",
-        #        "underlying": "LTC",
-        #        "quoteCurrency": "USDT",
-        #        "underlyingSymbol": "LTCT=",
-        #        "reference": "BMEX",
-        #        "referenceSymbol": ".BLTCT",
-        #        "calcInterval": null,
-        #        "publishInterval": null,
-        #        "publishTime": null,
-        #        "maxOrderQty": 1000000000,
-        #        "maxPrice": 1000000,
-        #        "lotSize": 1000,
-        #        "tickSize": 0.01,
-        #        "multiplier": 100,
-        #        "settlCurrency": "USDt",
-        #        "underlyingToPositionMultiplier": 10000,
-        #        "underlyingToSettleMultiplier": null,
-        #        "quoteToSettleMultiplier": 1000000,
-        #        "isQuanto": False,
-        #        "isInverse": False,
-        #        "initMargin": 0.03,
-        #        "maintMargin": 0.015,
-        #        "riskLimit": 1000000000000,
-        #        "riskStep": 1000000000000,
-        #        "limit": null,
-        #        "capped": False,
-        #        "taxed": True,
-        #        "deleverage": True,
-        #        "makerFee": -0.0001,
-        #        "takerFee": 0.0005,
-        #        "settlementFee": 0,
-        #        "insuranceFee": 0,
-        #        "fundingBaseSymbol": ".LTCBON8H",
-        #        "fundingQuoteSymbol": ".USDTBON8H",
-        #        "fundingPremiumSymbol": ".LTCUSDTPI8H",
-        #        "fundingTimestamp": "2022-01-14T20:00:00.000Z",
-        #        "fundingInterval": "2000-01-01T08:00:00.000Z",
-        #        "fundingRate": 0.0001,
-        #        "indicativeFundingRate": 0.0001,
-        #        "rebalanceTimestamp": null,
-        #        "rebalanceInterval": null,
-        #        "openingTimestamp": "2022-01-14T17:00:00.000Z",
-        #        "closingTimestamp": "2022-01-14T18:00:00.000Z",
-        #        "sessionInterval": "2000-01-01T01:00:00.000Z",
-        #        "prevClosePrice": 138.511,
-        #        "limitDownPrice": null,
-        #        "limitUpPrice": null,
-        #        "bankruptLimitDownPrice": null,
-        #        "bankruptLimitUpPrice": null,
-        #        "prevTotalVolume": 12699024000,
-        #        "totalVolume": 12702160000,
-        #        "volume": 3136000,
-        #        "volume24h": 114251000,
-        #        "prevTotalTurnover": 232418052349000,
-        #        "totalTurnover": 232463353260000,
-        #        "turnover": 45300911000,
-        #        "turnover24h": 1604331340000,
-        #        "homeNotional24h": 11425.1,
-        #        "foreignNotional24h": 1604331.3400000003,
-        #        "prevPrice24h": 135.48,
-        #        "vwap": 140.42165,
-        #        "highPrice": 146.42,
-        #        "lowPrice": 135.08,
-        #        "lastPrice": 144.36,
-        #        "lastPriceProtected": 144.36,
-        #        "lastTickDirection": "MinusTick",
-        #        "lastChangePcnt": 0.0655,
-        #        "bidPrice": 143.75,
-        #        "midPrice": 143.855,
-        #        "askPrice": 143.96,
-        #        "impactBidPrice": 143.75,
-        #        "impactMidPrice": 143.855,
-        #        "impactAskPrice": 143.96,
-        #        "hasLiquidity": True,
-        #        "openInterest": 38103000,
-        #        "openValue": 547963053300,
-        #        "fairMethod": "FundingRate",
-        #        "fairBasisRate": 0.1095,
-        #        "fairBasis": 0.004,
-        #        "fairPrice": 143.811,
-        #        "markMethod": "FairPrice",
-        #        "markPrice": 143.811,
-        #        "indicativeTaxRate": null,
-        #        "indicativeSettlePrice": 143.807,
-        #        "optionUnderlyingPrice": null,
-        #        "settledPriceAdjustmentRate": null,
-        #        "settledPrice": null,
-        #        "timestamp": "2022-01-14T17:49:55.000Z"
-        #    }
-        #
+        # see response sample under "fetchMarkets" because same endpoint is being used here
         datetime = self.safe_string(contract, 'timestamp')
         marketId = self.safe_string(contract, 'symbol')
         fundingDatetime = self.safe_string(contract, 'fundingTimestamp')
@@ -2383,18 +2330,18 @@ class bitmex(Exchange, ImplicitAPI):
         :returns dict: an `address structure <https://docs.ccxt.com/#/?id=address-structure>`
         """
         await self.load_markets()
-        networkCode = self.safe_string_upper(params, 'network')
+        networkCode = None
+        networkCode, params = self.handle_network_code_and_params(params)
         if networkCode is None:
             raise ArgumentsRequired(self.id + ' fetchDepositAddress requires params["network"]')
         currency = self.currency(code)
         currencyId = currency['id']
-        networkId = self.network_code_to_id(networkCode, currency['code'])
         idLength = len(currencyId)
         currencyId = currencyId[0:idLength - 1] + currencyId[idLength - 1:idLength].lower()  # make the last letter lowercase
         params = self.omit(params, 'network')
         request = {
             'currency': currencyId,
-            'network': networkId,
+            'network': self.network_code_to_id(networkCode, currency['code']),
         }
         response = await self.privateGetUserDepositAddress(self.extend(request, params))
         #
@@ -2404,10 +2351,111 @@ class bitmex(Exchange, ImplicitAPI):
             'currency': code,
             'address': response.replace('"', '').replace('"', ''),  # Done twice because some languages only replace the first instance
             'tag': None,
-            'network': self.network_id_to_code(networkId).upper(),
+            'network': networkCode,
             'info': response,
         }
 
+    def parse_deposit_withdraw_fee(self, fee, currency=None):
+        #
+        #    {
+        #        asset: 'XBT',
+        #        currency: 'XBt',
+        #        majorCurrency: 'XBT',
+        #        name: 'Bitcoin',
+        #        currencyType: 'Crypto',
+        #        scale: '8',
+        #        enabled: True,
+        #        isMarginCurrency: True,
+        #        minDepositAmount: '10000',
+        #        minWithdrawalAmount: '1000',
+        #        maxWithdrawalAmount: '100000000000000',
+        #        networks: [
+        #            {
+        #                asset: 'btc',
+        #                tokenAddress: '',
+        #                depositEnabled: True,
+        #                withdrawalEnabled: True,
+        #                withdrawalFee: '20000',
+        #                minFee: '20000',
+        #                maxFee: '10000000'
+        #            }
+        #        ]
+        #    }
+        #
+        networks = self.safe_value(fee, 'networks', [])
+        networksLength = len(networks)
+        result = {
+            'info': fee,
+            'withdraw': {
+                'fee': None,
+                'percentage': None,
+            },
+            'deposit': {
+                'fee': None,
+                'percentage': None,
+            },
+            'networks': {},
+        }
+        if networksLength != 0:
+            scale = self.safe_string(fee, 'scale')
+            precision = self.parse_precision(scale)
+            for i in range(0, networksLength):
+                network = networks[i]
+                networkId = self.safe_string(network, 'asset')
+                currencyCode = self.safe_string(currency, 'code')
+                networkCode = self.network_id_to_code(networkId, currencyCode)
+                withdrawalFeeId = self.safe_string(network, 'withdrawalFee')
+                withdrawalFee = self.parse_number(Precise.string_mul(withdrawalFeeId, precision))
+                result['networks'][networkCode] = {
+                    'deposit': {'fee': None, 'percentage': None},
+                    'withdraw': {'fee': withdrawalFee, 'percentage': False},
+                }
+                if networksLength == 1:
+                    result['withdraw']['fee'] = withdrawalFee
+                    result['withdraw']['percentage'] = False
+        return result
+
+    async def fetch_deposit_withdraw_fees(self, codes: Optional[List[str]] = None, params={}):
+        """
+        fetch deposit and withdraw fees
+        see https://www.bitmex.com/api/explorer/#not /Wallet/Wallet_getAssetsConfig
+        :param [str]|None codes: list of unified currency codes
+        :param dict params: extra parameters specific to the bitmex api endpoint
+        :returns dict: a list of `fee structures <https://docs.ccxt.com/en/latest/manual.html#fee-structure>`
+        """
+        await self.load_markets()
+        assets = await self.publicGetWalletAssets(params)
+        #
+        #    [
+        #        {
+        #            asset: 'XBT',
+        #            currency: 'XBt',
+        #            majorCurrency: 'XBT',
+        #            name: 'Bitcoin',
+        #            currencyType: 'Crypto',
+        #            scale: '8',
+        #            enabled: True,
+        #            isMarginCurrency: True,
+        #            minDepositAmount: '10000',
+        #            minWithdrawalAmount: '1000',
+        #            maxWithdrawalAmount: '100000000000000',
+        #            networks: [
+        #                {
+        #                    asset: 'btc',
+        #                    tokenAddress: '',
+        #                    depositEnabled: True,
+        #                    withdrawalEnabled: True,
+        #                    withdrawalFee: '20000',
+        #                    minFee: '20000',
+        #                    maxFee: '10000000'
+        #                }
+        #            ]
+        #        },
+        #        ...
+        #    ]
+        #
+        return self.parse_deposit_withdraw_fees(assets, codes, 'asset')
+
     def calculate_rate_limiter_cost(self, api, method, path, params, config={}):
         isAuthenticated = self.check_required_credentials(False)
         cost = self.safe_value(config, 'cost', 1)