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

ccxt/async_support/gate.py

@@ -24,7 +24,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
 
@@ -1798,100 +1797,80 @@ class gate(Exchange, ImplicitAPI):
             await self.load_unified_status()
         response = await 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
 
     async def fetch_funding_rate(self, symbol: str, params={}) -> FundingRate:
@@ -2136,6 +2115,27 @@ class gate(Exchange, ImplicitAPI):
             }
         return result
 
+    async 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
+        """
+        await self.load_markets()
+        currency = self.currency(code)
+        request = {
+            'currency': currency['id'],
+        }
+        response = await 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')
+
     async def fetch_deposit_address(self, code: str, params={}) -> DepositAddress:
         """
         fetch the deposit address for a currency associated with self account
@@ -2148,65 +2148,30 @@ class gate(Exchange, ImplicitAPI):
         :returns dict: an `address structure <https://docs.ccxt.com/#/?id=address-structure>`
         """
         await 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 = await self.privateWalletGetDepositAddress(self.extend(request, params))
+        networkCode = None
+        networkCode, params = self.handle_network_code_and_params(params)
+        chainsIndexedById = await 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')),
         }
 
     async def fetch_trading_fee(self, symbol: str, params={}) -> TradingFeeInterface:
@@ -3819,14 +3784,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 = await self.privateWithdrawalsPostWithdrawals(self.extend(request, params))
         #
         #    {

ccxt/async_support/phemex.py

@@ -5,6 +5,7 @@
 
 from ccxt.async_support.base.exchange import Exchange
 from ccxt.abstract.phemex import ImplicitAPI
+import asyncio
 import hashlib
 import numbers
 from ccxt.base.types import Any, Balances, Conversion, Currencies, Currency, DepositAddress, Int, LeverageTier, LeverageTiers, MarginModification, Market, Num, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, FundingRate, Trade, Transaction, TransferEntry
@@ -685,7 +686,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 +697,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 +885,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 = await self.v2GetPublicProducts(params)
+        v2ProductsPromise = self.v2GetPublicProducts(params)
         #
         #     {
         #         "code":0,
@@ -1030,7 +1035,8 @@ class phemex(Exchange, ImplicitAPI):
         #         }
         #     }
         #
-        v1Products = await self.v1GetExchangePublicProducts(params)
+        v1ProductsPromise = self.v1GetExchangePublicProducts(params)
+        v2Products, v1Products = await asyncio.gather(*[v2ProductsPromise, v1ProductsPromise])
         v1ProductsData = self.safe_value(v1Products, 'data', [])
         #
         #     {
@@ -1067,14 +1073,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 +1090,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/async_support/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/async_support/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 = {

ccxt/base/exchange.py

@@ -4,7 +4,7 @@
 
 # -----------------------------------------------------------------------------
 
-__version__ = '4.4.62'
+__version__ = '4.4.64'
 
 # -----------------------------------------------------------------------------
 
@@ -1450,11 +1450,11 @@ class Exchange(object):
 
     @staticmethod
     def encode(string):
-        return string.encode('latin-1')
+        return string.encode('utf-8')
 
     @staticmethod
     def decode(string):
-        return string.decode('latin-1')
+        return string.decode('utf-8')
 
     @staticmethod
     def to_array(value):
@@ -2903,6 +2903,9 @@ class Exchange(object):
 
     def safe_currency_structure(self, currency: object):
         # derive data from networks: deposit, withdraw, active, fee, limits, precision
+        currencyDeposit = self.safe_bool(currency, 'deposit')
+        currencyWithdraw = self.safe_bool(currency, 'withdraw')
+        currencyActive = self.safe_bool(currency, 'active')
         networks = self.safe_dict(currency, 'networks', {})
         keys = list(networks.keys())
         length = len(keys)
@@ -2910,13 +2913,13 @@ class Exchange(object):
             for i in range(0, length):
                 network = networks[keys[i]]
                 deposit = self.safe_bool(network, 'deposit')
-                if currency['deposit'] is None or deposit:
+                if currencyDeposit is None or deposit:
                     currency['deposit'] = deposit
                 withdraw = self.safe_bool(network, 'withdraw')
-                if currency['withdraw'] is None or withdraw:
+                if currencyWithdraw is None or withdraw:
                     currency['withdraw'] = withdraw
                 active = self.safe_bool(network, 'active')
-                if currency['active'] is None or active:
+                if currencyActive is None or active:
                     currency['active'] = active
                 # find lowest fee(which is more desired)
                 fee = self.safe_string(network, 'fee')
@@ -4065,7 +4068,9 @@ class Exchange(object):
                 # if networkCode was not provided by user, then we try to use the default network(if it was defined in "defaultNetworks"), otherwise, we just return the first network entry
                 defaultNetworkCode = self.default_network_code(currencyCode)
                 defaultNetworkId = defaultNetworkCode if isIndexedByUnifiedNetworkCode else self.network_code_to_id(defaultNetworkCode, currencyCode)
-                chosenNetworkId = defaultNetworkId if (defaultNetworkId in indexedNetworkEntries) else availableNetworkIds[0]
+                if defaultNetworkId in indexedNetworkEntries:
+                    return defaultNetworkId
+                raise NotSupported(self.id + ' - can not determine the default network, please pass param["network"] one from : ' + ', '.join(availableNetworkIds))
         return chosenNetworkId
 
     def safe_number_2(self, dictionary: object, key1: IndexType, key2: IndexType, d=None):

ccxt/binance.py

@@ -503,6 +503,7 @@ class binance(Exchange, ImplicitAPI):
                         'portfolio/margin-asset-leverage': 5,  # Weight(IP): 50 => cost = 0.1 * 50 = 5
                         'portfolio/balance': 2,
                         'portfolio/negative-balance-exchange-record': 2,
+                        'portfolio/pmloan-history': 5,
                         # staking
                         'staking/productList': 0.1,
                         'staking/position': 0.1,
@@ -6163,11 +6164,10 @@ class binance(Exchange, ImplicitAPI):
         """
         self.load_markets()
         market = self.market(symbol)
+        # don't handle/omit params here, omitting happens inside createOrderRequest
         marketType = self.safe_string(params, 'type', market['type'])
-        marginMode = None
-        marginMode, params = self.handle_margin_mode_and_params('createOrder', params)
-        isPortfolioMargin = None
-        isPortfolioMargin, params = self.handle_option_and_params_2(params, 'createOrder', 'papi', 'portfolioMargin', False)
+        marginMode = self.safe_string(params, 'marginMode')
+        isPortfolioMargin = self.safe_bool_2(params, 'papi', 'portfolioMargin', False)
         triggerPrice = self.safe_string_2(params, 'triggerPrice', 'stopPrice')
         stopLossPrice = self.safe_string(params, 'stopLossPrice')
         takeProfitPrice = self.safe_string(params, 'takeProfitPrice')

ccxt/bingx.py

@@ -4471,7 +4471,7 @@ class bingx(Exchange, ImplicitAPI):
             response = self.contractV1PrivateGetAllOrders(self.extend(request, params))
         elif type == 'spot':
             if limit is not None:
-                request['limit'] = limit
+                request['pageSize'] = limit
             response = self.spotV1PrivateGetTradeHistoryOrders(self.extend(request, params))
             #
             #    {