ccxt 4.4.62__py2.py3-none-any.whl → 4.4.64__py2.py3-none-any.whl

ccxt/gate.py

@@ -23,7 +23,6 @@ from ccxt.base.errors import OrderImmediatelyFillable
 from ccxt.base.errors import NotSupported
 from ccxt.base.errors import RateLimitExceeded
 from ccxt.base.errors import ExchangeNotAvailable
-from ccxt.base.errors import BadResponse
 from ccxt.base.decimal_to_precision import TICK_SIZE
 from ccxt.base.precise import Precise
 
@@ -1797,100 +1796,80 @@ class gate(Exchange, ImplicitAPI):
             self.load_unified_status()
         response = self.publicSpotGetCurrencies(params)
         #
-        #    {
-        #        "currency": "BCN",
-        #        "delisted": False,
-        #        "withdraw_disabled": True,
-        #        "withdraw_delayed": False,
-        #        "deposit_disabled": True,
-        #        "trade_disabled": False
-        #    }
-        #
-        #    {
-        #        "currency":"USDT_ETH",
-        #        "delisted":false,
-        #        "withdraw_disabled":false,
-        #        "withdraw_delayed":false,
-        #        "deposit_disabled":false,
-        #        "trade_disabled":false,
-        #        "chain":"ETH"
-        #    }
-        #
+        #  [
+        #   {
+        #       "currency": "USDT_ETH",
+        #       "name": "Tether",
+        #       "delisted": False,
+        #       "withdraw_disabled": False,
+        #       "withdraw_delayed": False,
+        #       "deposit_disabled": False,
+        #       "trade_disabled": True,
+        #       "chain": "ETH"
+        #    },
+        #  ]
+        #
+        indexedCurrencies = self.index_by(response, 'currency')
         result: dict = {}
         for i in range(0, len(response)):
             entry = response[i]
             currencyId = self.safe_string(entry, 'currency')
-            currencyIdLower = self.safe_string_lower(entry, 'currency')
             parts = currencyId.split('_')
-            currency = parts[0]
-            code = self.safe_currency_code(currency)
-            networkId = self.safe_string(entry, 'chain')
-            networkCode = None
-            if networkId is not None:
-                networkCode = self.network_id_to_code(networkId, code)
-            delisted = self.safe_value(entry, 'delisted')
-            withdrawDisabled = self.safe_bool(entry, 'withdraw_disabled', False)
-            depositDisabled = self.safe_bool(entry, 'deposit_disabled', False)
-            tradeDisabled = self.safe_bool(entry, 'trade_disabled', False)
-            withdrawEnabled = not withdrawDisabled
-            depositEnabled = not depositDisabled
-            tradeEnabled = not tradeDisabled
-            listed = not delisted
-            active = listed and tradeEnabled and withdrawEnabled and depositEnabled
-            if self.safe_value(result, code) is None:
+            partFirst = self.safe_string(parts, 0)
+            # if there's an underscore then the second part is always the chain name(except the _OLD suffix)
+            currencyName = currencyId if currencyId.endswith('_OLD') else partFirst
+            withdrawEnabled = not self.safe_bool(entry, 'withdraw_disabled')
+            depositEnabled = not self.safe_bool(entry, 'deposit_disabled')
+            tradeDisabled = not self.safe_bool(entry, 'trade_disabled')
+            precision = self.parse_number('0.0001')  # temporary safe default, because no value provided from API
+            code = self.safe_currency_code(currencyName)
+            # check leveraged tokens(e.g. BTC3S, ETH5L)
+            isLeveragedToken = False
+            if currencyId.endswith('3S') or currencyId.endswith('3L') or currencyId.endswith('5S') or currencyId.endswith('5L'):
+                realCurrencyId = currencyId[0:-2]
+                if realCurrencyId in indexedCurrencies:
+                    isLeveragedToken = True
+            type = 'leveraged' if isLeveragedToken else 'crypto'
+            # some networks are null, they are mostly obsolete & unsupported dead tokens, so we can default their networkId to their tokenname
+            networkId = self.safe_string(entry, 'chain', currencyId)
+            networkCode = self.network_id_to_code(networkId, code)
+            networkEntry = {
+                'info': entry,
+                'id': networkId,
+                'network': networkCode,
+                'limits': {
+                    'deposit': {
+                        'min': None,
+                        'max': None,
+                    },
+                    'withdraw': {
+                        'min': None,
+                        'max': None,
+                    },
+                },
+                'active': not tradeDisabled,
+                'deposit': depositEnabled,
+                'withdraw': withdrawEnabled,
+                'fee': None,
+                'precision': precision,
+            }
+            # check if first entry for the specific currency
+            if not (code in result):
                 result[code] = {
-                    'id': currency,
+                    'id': currencyName,
+                    'lowerCaseId': currencyName.lower(),
                     'code': code,
-                    'info': None,
-                    'name': None,
-                    'active': active,
-                    'deposit': depositEnabled,
-                    'withdraw': withdrawEnabled,
-                    'fee': None,
-                    'fees': [],
-                    'precision': self.parse_number('1e-4'),
+                    'type': type,
+                    'precision': precision,
                     'limits': self.limits,
                     'networks': {},
+                    'info': [],  # will be filled below
                 }
-            depositAvailable = self.safe_value(result[code], 'deposit')
-            depositAvailable = depositEnabled if (depositEnabled) else depositAvailable
-            withdrawAvailable = self.safe_value(result[code], 'withdraw')
-            withdrawAvailable = withdrawEnabled if (withdrawEnabled) else withdrawAvailable
-            networks = self.safe_value(result[code], 'networks', {})
-            if networkCode is not None:
-                networks[networkCode] = {
-                    'info': entry,
-                    'id': networkId,
-                    'network': networkCode,
-                    'currencyId': currencyId,
-                    'lowerCaseCurrencyId': currencyIdLower,
-                    'deposit': depositEnabled,
-                    'withdraw': withdrawEnabled,
-                    'active': active,
-                    'fee': None,
-                    'precision': self.parse_number('1e-4'),
-                    'limits': {
-                        'amount': {
-                            'min': None,
-                            'max': None,
-                        },
-                        'withdraw': {
-                            'min': None,
-                            'max': None,
-                        },
-                        'deposit': {
-                            'min': None,
-                            'max': None,
-                        },
-                    },
-                }
-            result[code]['networks'] = networks
-            info = self.safe_value(result[code], 'info', [])
+            result[code]['networks'][networkCode] = networkEntry
+            info = self.safe_list(result[code], 'info', [])
             info.append(entry)
             result[code]['info'] = info
-            result[code]['active'] = depositAvailable and withdrawAvailable
-            result[code]['deposit'] = depositAvailable
-            result[code]['withdraw'] = withdrawAvailable
+            result[code] = self.safe_currency_structure(result[code])  # self is needed after adding network entry
         return result
 
     def fetch_funding_rate(self, symbol: str, params={}) -> FundingRate:
@@ -2135,6 +2114,27 @@ class gate(Exchange, ImplicitAPI):
             }
         return result
 
+    def fetch_deposit_addresses_by_network(self, code: str, params={}) -> List[DepositAddress]:
+        """
+        fetch a dictionary of addresses for a currency, indexed by network
+        :param str code: unified currency code of the currency for the deposit address
+        :param dict [params]: extra parameters specific to the api endpoint
+        :returns dict: a dictionary of `address structures <https://docs.ccxt.com/#/?id=address-structure>` indexed by the network
+        """
+        self.load_markets()
+        currency = self.currency(code)
+        request = {
+            'currency': currency['id'],
+        }
+        response = self.privateWalletGetDepositAddress(self.extend(request, params))
+        chains = self.safe_value(response, 'multichain_addresses', [])
+        currencyId = self.safe_string(response, 'currency')
+        currency = self.safe_currency(currencyId, currency)
+        parsed = self.parse_deposit_addresses(chains, [currency['code']], False, {
+            'currency': currency['id'],
+        })
+        return self.index_by(parsed, 'network')
+
     def fetch_deposit_address(self, code: str, params={}) -> DepositAddress:
         """
         fetch the deposit address for a currency associated with self account
@@ -2147,65 +2147,30 @@ class gate(Exchange, ImplicitAPI):
         :returns dict: an `address structure <https://docs.ccxt.com/#/?id=address-structure>`
         """
         self.load_markets()
-        currency = self.currency(code)
-        rawNetwork = self.safe_string_upper(params, 'network')
-        params = self.omit(params, 'network')
-        request: dict = {
-            'currency': currency['id'],  # todo: currencies have network-junctions
-        }
-        response = self.privateWalletGetDepositAddress(self.extend(request, params))
+        networkCode = None
+        networkCode, params = self.handle_network_code_and_params(params)
+        chainsIndexedById = self.fetch_deposit_addresses_by_network(code, params)
+        selectedNetworkId = self.select_network_code_from_unified_networks(code, networkCode, chainsIndexedById)
+        return chainsIndexedById[selectedNetworkId]
+
+    def parse_deposit_address(self, depositAddress, currency=None):
         #
-        #    {
-        #        "currency": "XRP",
-        #        "address": "rHcFoo6a9qT5NHiVn1THQRhsEGcxtYCV4d 391331007",
-        #        "multichain_addresses": [
-        #            {
-        #                "chain": "XRP",
-        #                "address": "rHcFoo6a9qT5NHiVn1THQRhsEGcxtYCV4d",
-        #                "payment_id": "391331007",
-        #                "payment_name": "Tag",
-        #                "obtain_failed": 0
-        #            }
-        #        ]
-        #    }
+        #     {
+        #         chain: "BTC",
+        #         address: "1Nxu.......Ys",
+        #         payment_id: "",
+        #         payment_name: "",
+        #         obtain_failed: "0",
+        #     }
         #
-        currencyId = self.safe_string(response, 'currency')
-        code = self.safe_currency_code(currencyId)
-        networkId = self.network_code_to_id(rawNetwork, code)
-        network = None
-        tag = None
-        address = None
-        if networkId is not None:
-            addresses = self.safe_value(response, 'multichain_addresses')
-            for i in range(0, len(addresses)):
-                entry = addresses[i]
-                entryNetwork = self.safe_string(entry, 'chain')
-                if networkId == entryNetwork:
-                    obtainFailed = self.safe_integer(entry, 'obtain_failed')
-                    if obtainFailed:
-                        break
-                    address = self.safe_string(entry, 'address')
-                    tag = self.safe_string(entry, 'payment_id')
-                    network = self.network_id_to_code(networkId, code)
-                    break
-        else:
-            addressField = self.safe_string(response, 'address')
-            if addressField is not None:
-                if addressField.find('New address is being generated for you, please wait') >= 0:
-                    raise BadResponse(self.id + ' ' + 'New address is being generated for you, please wait a few seconds and try again to get the address.')
-                if addressField.find(' ') >= 0:
-                    splitted = addressField.split(' ')
-                    address = splitted[0]
-                    tag = splitted[1]
-                else:
-                    address = addressField
+        address = self.safe_string(depositAddress, 'address')
         self.check_address(address)
         return {
-            'info': response,
-            'currency': code,
-            'network': network,
+            'info': depositAddress,
+            'currency': self.safe_string(currency, 'code'),
             'address': address,
-            'tag': tag,
+            'tag': self.safe_string(depositAddress, 'payment_id'),
+            'network': self.network_id_to_code(self.safe_string(depositAddress, 'chain')),
         }
 
     def fetch_trading_fee(self, symbol: str, params={}) -> TradingFeeInterface:
@@ -3818,14 +3783,10 @@ class gate(Exchange, ImplicitAPI):
         }
         if tag is not None:
             request['memo'] = tag
-        networks = self.safe_value(self.options, 'networks', {})
-        network = self.safe_string_upper(params, 'network')  # self line allows the user to specify either ERC20 or ETH
-        network = self.safe_string_lower(networks, network, network)  # handle ETH>ERC20 alias
-        if network is not None:
-            request['chain'] = network
-            params = self.omit(params, 'network')
-        else:
-            request['chain'] = currency['id']  # todo: currencies have network-junctions
+        networkCode = None
+        networkCode, params = self.handle_network_code_and_params(params)
+        if networkCode is not None:
+            request['chain'] = self.network_code_to_id(networkCode)
         response = self.privateWithdrawalsPostWithdrawals(self.extend(request, params))
         #
         #    {

ccxt/phemex.py

@@ -685,7 +685,8 @@ class phemex(Exchange, ImplicitAPI):
         #     }
         #
         id = self.safe_string(market, 'symbol')
-        baseId = self.safe_string_2(market, 'baseCurrency', 'contractUnderlyingAssets')
+        contractUnderlyingAssets = self.safe_string(market, 'contractUnderlyingAssets')
+        baseId = self.safe_string(market, 'baseCurrency', contractUnderlyingAssets)
         quoteId = self.safe_string(market, 'quoteCurrency')
         settleId = self.safe_string(market, 'settleCurrency')
         base = self.safe_currency_code(baseId)
@@ -695,6 +696,9 @@ class phemex(Exchange, ImplicitAPI):
         inverse = False
         if settleId != quoteId:
             inverse = True
+            # some unhandled cases
+            if not ('baseCurrency' in market) and base == quote:
+                base = settle
         priceScale = self.safe_integer(market, 'priceScale')
         ratioScale = self.safe_integer(market, 'ratioScale')
         valueScale = self.safe_integer(market, 'valueScale')
@@ -880,7 +884,7 @@ class phemex(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: an array of objects representing market data
         """
-        v2Products = self.v2GetPublicProducts(params)
+        v2ProductsPromise = self.v2GetPublicProducts(params)
         #
         #     {
         #         "code":0,
@@ -1030,7 +1034,8 @@ class phemex(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        v1Products = self.v1GetExchangePublicProducts(params)
+        v1ProductsPromise = self.v1GetExchangePublicProducts(params)
+        v2Products, v1Products = [v2ProductsPromise, v1ProductsPromise]
         v1ProductsData = self.safe_value(v1Products, 'data', [])
         #
         #     {
@@ -1067,14 +1072,14 @@ class phemex(Exchange, ImplicitAPI):
         #         ]
         #     }
         #
-        v2ProductsData = self.safe_value(v2Products, 'data', {})
-        products = self.safe_value(v2ProductsData, 'products', [])
-        perpetualProductsV2 = self.safe_value(v2ProductsData, 'perpProductsV2', [])
+        v2ProductsData = self.safe_dict(v2Products, 'data', {})
+        products = self.safe_list(v2ProductsData, 'products', [])
+        perpetualProductsV2 = self.safe_list(v2ProductsData, 'perpProductsV2', [])
         products = self.array_concat(products, perpetualProductsV2)
-        riskLimits = self.safe_value(v2ProductsData, 'riskLimits', [])
-        riskLimitsV2 = self.safe_value(v2ProductsData, 'riskLimitsV2', [])
+        riskLimits = self.safe_list(v2ProductsData, 'riskLimits', [])
+        riskLimitsV2 = self.safe_list(v2ProductsData, 'riskLimitsV2', [])
         riskLimits = self.array_concat(riskLimits, riskLimitsV2)
-        currencies = self.safe_value(v2ProductsData, 'currencies', [])
+        currencies = self.safe_list(v2ProductsData, 'currencies', [])
         riskLimitsById = self.index_by(riskLimits, 'symbol')
         v1ProductsById = self.index_by(v1ProductsData, 'symbol')
         currenciesByCode = self.index_by(currencies, 'currency')
@@ -1084,14 +1089,14 @@ class phemex(Exchange, ImplicitAPI):
             type = self.safe_string_lower(market, 'type')
             if (type == 'perpetual') or (type == 'perpetualv2') or (type == 'perpetualpilot'):
                 id = self.safe_string(market, 'symbol')
-                riskLimitValues = self.safe_value(riskLimitsById, id, {})
+                riskLimitValues = self.safe_dict(riskLimitsById, id, {})
                 market = self.extend(market, riskLimitValues)
-                v1ProductsValues = self.safe_value(v1ProductsById, id, {})
+                v1ProductsValues = self.safe_dict(v1ProductsById, id, {})
                 market = self.extend(market, v1ProductsValues)
                 market = self.parse_swap_market(market)
             else:
                 baseCurrency = self.safe_string(market, 'baseCurrency')
-                currencyValues = self.safe_value(currenciesByCode, baseCurrency, {})
+                currencyValues = self.safe_dict(currenciesByCode, baseCurrency, {})
                 valueScale = self.safe_string(currencyValues, 'valueScale', '8')
                 market = self.extend(market, {'valueScale': valueScale})
                 market = self.parse_spot_market(market)

ccxt/pro/__init__.py

@@ -4,7 +4,7 @@
 
 # ----------------------------------------------------------------------------
 
-__version__ = '4.4.62'
+__version__ = '4.4.64'
 
 # ----------------------------------------------------------------------------
 

ccxt/pro/bitmart.py

@@ -131,8 +131,10 @@ class bitmart(ccxt.async_support.bitmart):
             rawSubscriptions.append(message)
             messageHashes.append(channel + ':' + market['symbol'])
         # exclusion, futures "tickers" need one generic request for all symbols
-        if (type != 'spot') and (channel == 'ticker'):
-            rawSubscriptions = [channelType + '/' + channel]
+        # if (type != 'spot') and (channel == 'ticker'):
+        #     rawSubscriptions = [channelType + '/' + channel]
+        # }
+        # Exchange update from 2025-02-11 supports subscription by trading pair for swap
         request: dict = {
             'args': rawSubscriptions,
         }
@@ -898,39 +900,42 @@ class bitmart(ccxt.async_support.bitmart):
 
     def parse_ws_trade(self, trade: dict, market: Market = None):
         # spot
-        #    {
-        #        "price": "52700.50",
-        #        "s_t": 1630982050,
-        #        "side": "buy",
-        #        "size": "0.00112",
-        #        "symbol": "BTC_USDT"
-        #    }
+        #     {
+        #         "ms_t": 1740320841473,
+        #         "price": "2806.54",
+        #         "s_t": 1740320841,
+        #         "side": "sell",
+        #         "size": "0.77598",
+        #         "symbol": "ETH_USDT"
+        #     }
+        #
         # swap
-        #    {
-        #       "trade_id":6798697637,
-        #       "contract_id":1,
-        #       "symbol":"BTCUSDT",
-        #       "deal_price":"39735.8",
-        #       "deal_vol":"2",
-        #       "type":0,
-        #       "way":1,
-        #       "create_time":1701618503,
-        #       "create_time_mill":1701618503517,
-        #       "created_at":"2023-12-03T15:48:23.517518538Z"
-        #    }
+        #     {
+        #         "trade_id": "3000000245258661",
+        #         "symbol": "ETHUSDT",
+        #         "deal_price": "2811.1",
+        #         "deal_vol": "1858",
+        #         "way": 2,
+        #         "m": True,
+        #         "created_at": "2025-02-23T13:59:59.646490751Z"
+        #     }
         #
-        contractId = self.safe_string(trade, 'contract_id')
-        marketType = 'spot' if (contractId is None) else 'swap'
-        marketDelimiter = '_' if (marketType == 'spot') else ''
-        timestamp = self.safe_integer(trade, 'create_time_mill', self.safe_timestamp(trade, 's_t'))
         marketId = self.safe_string(trade, 'symbol')
+        market = self.safe_market(marketId, market)
+        timestamp = self.safe_integer(trade, 'ms_t')
+        datetime: Str = None
+        if timestamp is None:
+            datetime = self.safe_string(trade, 'created_at')
+            timestamp = self.parse8601(datetime)
+        else:
+            datetime = self.iso8601(timestamp)
         return self.safe_trade({
             'info': trade,
             'id': self.safe_string(trade, 'trade_id'),
             'order': None,
             'timestamp': timestamp,
-            'datetime': self.iso8601(timestamp),
-            'symbol': self.safe_symbol(marketId, market, marketDelimiter, marketType),
+            'datetime': datetime,
+            'symbol': market['symbol'],
             'type': None,
             'side': self.safe_string(trade, 'side'),
             'price': self.safe_string_2(trade, 'price', 'deal_price'),
@@ -956,20 +961,22 @@ class bitmart(ccxt.async_support.bitmart):
         #        ],
         #        "table": "spot/ticker"
         #    }
-        #    {
-        #        "group":"futures/ticker",
-        #        "data":{
-        #              "symbol":"BTCUSDT",
-        #              "volume_24":"117387.58",
-        #              "fair_price":"146.24",
-        #              "last_price":"146.24",
-        #              "range":"147.17",
-        #              "ask_price": "147.11",
-        #              "ask_vol": "1",
-        #              "bid_price": "142.11",
-        #              "bid_vol": "1"
-        #            }
-        #    }
+        #
+        #     {
+        #         "data": {
+        #             "symbol": "ETHUSDT",
+        #             "last_price": "2807.73",
+        #             "volume_24": "2227011952",
+        #             "range": "0.0273398194664491",
+        #             "mark_price": "2807.5",
+        #             "index_price": "2808.71047619",
+        #             "ask_price": "2808.04",
+        #             "ask_vol": "7371",
+        #             "bid_price": "2807.28",
+        #             "bid_vol": "3561"
+        #         },
+        #         "group": "futures/ticker:ETHUSDT@100ms"
+        #     }
         #
         self.handle_bid_ask(client, message)
         table = self.safe_string(message, 'table')
@@ -990,17 +997,19 @@ class bitmart(ccxt.async_support.bitmart):
 
     def parse_ws_swap_ticker(self, ticker, market: Market = None):
         #
-        #    {
-        #        "symbol":"BTCUSDT",
-        #        "volume_24":"117387.58",
-        #        "fair_price":"146.24",
-        #        "last_price":"146.24",
-        #        "range":"147.17",
-        #        "ask_price": "147.11",
-        #        "ask_vol": "1",
-        #        "bid_price": "142.11",
-        #        "bid_vol": "1"
-        #    }
+        #     {
+        #         "symbol": "ETHUSDT",
+        #         "last_price": "2807.73",
+        #         "volume_24": "2227011952",
+        #         "range": "0.0273398194664491",
+        #         "mark_price": "2807.5",
+        #         "index_price": "2808.71047619",
+        #         "ask_price": "2808.04",
+        #         "ask_vol": "7371",
+        #         "bid_price": "2807.28",
+        #         "bid_vol": "3561"
+        #     }
+        #
         marketId = self.safe_string(ticker, 'symbol')
         return self.safe_ticker({
             'symbol': self.safe_symbol(marketId, market, '', 'swap'),
@@ -1019,10 +1028,12 @@ class bitmart(ccxt.async_support.bitmart):
             'previousClose': None,
             'change': None,
             'percentage': None,
-            'average': self.safe_string(ticker, 'fair_price'),
+            'average': None,
             'baseVolume': None,
             'quoteVolume': self.safe_string(ticker, 'volume_24'),
             'info': ticker,
+            'markPrice': self.safe_string(ticker, 'mark_price'),
+            'indexPrice': self.safe_string(ticker, 'index_price'),
         }, market)
 
     async def watch_ohlcv(self, symbol: str, timeframe='1m', since: Int = None, limit: Int = None, params={}) -> List[list]:

ccxt/pro/bitopro.py

@@ -77,7 +77,7 @@ class bitopro(ccxt.async_support.bitopro):
         if limit is None:
             endPart = market['id']
         else:
-            endPart = market['id'] + ':' + limit
+            endPart = market['id'] + ':' + self.number_to_string(limit)
         orderbook = await self.watch_public('order-books', messageHash, endPart)
         return orderbook.limit()
 

ccxt/pro/gate.py

@@ -1892,6 +1892,10 @@ class gate(ccxt.async_support.gate):
             'signature': signature,
             'req_param': reqParams,
         }
+        if (channel == 'spot.order_place') or (channel == 'futures.order_place'):
+            payload['req_header'] = {
+                'x-gate-channel-id': 'ccxt',
+            }
         request: dict = {
             'id': requestId,
             'time': time,

ccxt/pro/vertex.py

@@ -55,6 +55,11 @@ class vertex(ccxt.async_support.vertex):
                 },
                 'ws': {
                     'inflate': True,
+                    'options': {
+                        'headers': {
+                            'Sec-WebSocket-Extensions': 'permessage-deflate',  # requires permessage-deflate extension, maybe we can set self in client implementation when self.inflateis True
+                        },
+                    },
                 },
             },
             'streaming': {

ccxt/tradeogre.py

@@ -511,11 +511,11 @@ class tradeogre(Exchange, ImplicitAPI):
         if type == 'market':
             raise BadRequest(self.id + ' createOrder does not support market orders')
         if price is None:
-            raise ArgumentsRequired(self.id + ' createOrder requires a limit parameter')
+            raise ArgumentsRequired(self.id + ' createOrder requires a price parameter')
         request: dict = {
             'market': market['id'],
-            'quantity': self.parse_to_numeric(self.amount_to_precision(symbol, amount)),
-            'price': self.parse_to_numeric(self.price_to_precision(symbol, price)),
+            'quantity': self.amount_to_precision(symbol, amount),
+            'price': self.price_to_precision(symbol, price),
         }
         response = None
         if side == 'buy':

ccxt/whitebit.py

@@ -2603,12 +2603,10 @@ class whitebit(Exchange, ImplicitAPI):
                 url += '?' + self.urlencode(query)
         if accessibility == 'private':
             self.check_required_credentials()
-            nonce = self.nonce()
-            timestamp = self.parse_to_int(nonce / 1000)
-            timestampString = str(timestamp)
+            nonce = str(self.nonce())
             secret = self.encode(self.secret)
             request = '/' + 'api' + '/' + version + pathWithParams
-            body = self.json(self.extend({'request': request, 'nonce': timestampString}, params))
+            body = self.json(self.extend({'request': request, 'nonce': nonce}, params))
             payload = self.string_to_base64(body)
             signature = self.hmac(self.encode(payload), secret, hashlib.sha512)
             headers = {