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

ccxt/btcbox.py

@@ -115,6 +115,18 @@ class btcbox(Exchange, ImplicitAPI):
                         'wallet',
                     ],
                 },
+                'webApi': {
+                    'get': [
+                        'ajax/coin/coinInfo',
+                    ],
+                },
+            },
+            'options': {
+                'fetchMarkets': {
+                    'webApiEnable': True,  # fetches from WEB
+                    'webApiRetries': 3,
+                },
+                'amountPrecision': '0.0001',  # exchange has only few pairs and all of them
             },
             'features': {
                 'spot': {
@@ -198,9 +210,12 @@ class btcbox(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict[]: an array of objects representing market data
         """
-        response = self.publicGetTickers()
+        promise1 = self.publicGetTickers()
+        promise2 = self.fetch_web_endpoint('fetchMarkets', 'webApiGetAjaxCoinCoinInfo', True)
+        response1, response2 = [promise1, promise2]
         #
-        marketIds = list(response.keys())
+        result2Data = self.safe_dict(response2, 'data', {})
+        marketIds = list(response1.keys())
         markets = []
         for i in range(0, len(marketIds)):
             marketId = marketIds[i]
@@ -209,9 +224,11 @@ class btcbox(Exchange, ImplicitAPI):
             quote = self.safe_string(symbolParts, 1)
             quoteId = quote.lower()
             id = baseCurr.lower()
-            res = response[marketId]
+            res = response1[marketId]
             symbol = baseCurr + '/' + quote
             fee = self.parse_number('0.0005') if (id == 'BTC') else self.parse_number('0.0010')
+            details = self.safe_dict(result2Data, id, {})
+            tradeDetails = self.safe_dict(details, 'trade', {})
             markets.append(self.safe_market_structure({
                 'id': id,
                 'uppercaseId': None,
@@ -257,10 +274,10 @@ class btcbox(Exchange, ImplicitAPI):
                     },
                 },
                 'precision': {
-                    'price': None,
+                    'price': self.parse_number(self.parse_precision(self.safe_string(tradeDetails, 'pricedecimal'))),
                     'amount': None,
                 },
-                'active': None,
+                'active': self.safe_string(tradeDetails, 'enable') == '1',
                 'created': None,
                 'info': res,
             }))
@@ -717,6 +734,8 @@ class btcbox(Exchange, ImplicitAPI):
         if api == 'public':
             if params:
                 url += '?' + self.urlencode(params)
+        elif api == 'webApi':
+            url = self.urls['www'] + '/' + path
         else:
             self.check_required_credentials()
             nonce = str(self.nonce())

ccxt/bybit.py

@@ -1634,78 +1634,57 @@ class bybit(Exchange, ImplicitAPI):
             name = self.safe_string(currency, 'name')
             chains = self.safe_list(currency, 'chains', [])
             networks: dict = {}
-            minPrecision = None
-            minWithdrawFeeString = None
-            minWithdrawString = None
-            minDepositString = None
-            deposit = False
-            withdraw = False
             for j in range(0, len(chains)):
                 chain = chains[j]
                 networkId = self.safe_string(chain, 'chain')
                 networkCode = self.network_id_to_code(networkId)
-                precision = self.parse_number(self.parse_precision(self.safe_string(chain, 'minAccuracy')))
-                minPrecision = precision if (minPrecision is None) else min(minPrecision, precision)
-                depositAllowed = self.safe_integer(chain, 'chainDeposit') == 1
-                deposit = depositAllowed if (depositAllowed) else deposit
-                withdrawAllowed = self.safe_integer(chain, 'chainWithdraw') == 1
-                withdraw = withdrawAllowed if (withdrawAllowed) else withdraw
-                withdrawFeeString = self.safe_string(chain, 'withdrawFee')
-                if withdrawFeeString is not None:
-                    minWithdrawFeeString = withdrawFeeString if (minWithdrawFeeString is None) else Precise.string_min(withdrawFeeString, minWithdrawFeeString)
-                minNetworkWithdrawString = self.safe_string(chain, 'withdrawMin')
-                if minNetworkWithdrawString is not None:
-                    minWithdrawString = minNetworkWithdrawString if (minWithdrawString is None) else Precise.string_min(minNetworkWithdrawString, minWithdrawString)
-                minNetworkDepositString = self.safe_string(chain, 'depositMin')
-                if minNetworkDepositString is not None:
-                    minDepositString = minNetworkDepositString if (minDepositString is None) else Precise.string_min(minNetworkDepositString, minDepositString)
                 networks[networkCode] = {
                     'info': chain,
                     'id': networkId,
                     'network': networkCode,
-                    'active': depositAllowed and withdrawAllowed,
-                    'deposit': depositAllowed,
-                    'withdraw': withdrawAllowed,
-                    'fee': self.parse_number(withdrawFeeString),
-                    'precision': precision,
+                    'active': None,
+                    'deposit': self.safe_integer(chain, 'chainDeposit') == 1,
+                    'withdraw': self.safe_integer(chain, 'chainWithdraw') == 1,
+                    'fee': self.safe_number(chain, 'withdrawFee'),
+                    'precision': self.parse_number(self.parse_precision(self.safe_string(chain, 'minAccuracy'))),
                     'limits': {
                         'withdraw': {
-                            'min': self.parse_number(minNetworkWithdrawString),
+                            'min': self.safe_number(chain, 'withdrawMin'),
                             'max': None,
                         },
                         'deposit': {
-                            'min': self.parse_number(minNetworkDepositString),
+                            'min': self.safe_number(chain, 'depositMin'),
                             'max': None,
                         },
                     },
                 }
-            result[code] = {
+            result[code] = self.safe_currency_structure({
                 'info': currency,
                 'code': code,
                 'id': currencyId,
                 'name': name,
-                'active': deposit and withdraw,
-                'deposit': deposit,
-                'withdraw': withdraw,
-                'fee': self.parse_number(minWithdrawFeeString),
-                'precision': minPrecision,
+                'active': None,
+                'deposit': None,
+                'withdraw': None,
+                'fee': None,
+                'precision': None,
                 'limits': {
                     'amount': {
                         'min': None,
                         'max': None,
                     },
                     'withdraw': {
-                        'min': self.parse_number(minWithdrawString),
+                        'min': None,
                         'max': None,
                     },
                     'deposit': {
-                        'min': self.parse_number(minDepositString),
+                        'min': None,
                         'max': None,
                     },
                 },
                 'networks': networks,
                 'type': 'crypto',  # atm exchange api provides only cryptos
-            }
+            })
         return result
 
     def fetch_markets(self, params={}) -> List[Market]:

ccxt/cex.py

@@ -310,8 +310,6 @@ class cex(Exchange, ImplicitAPI):
         id = self.safe_string(rawCurrency, 'currency')
         code = self.safe_currency_code(id)
         type = 'fiat' if self.safe_bool(rawCurrency, 'fiat') else 'crypto'
-        currencyDepositEnabled = self.safe_bool(rawCurrency, 'walletDeposit')
-        currencyWithdrawEnabled = self.safe_bool(rawCurrency, 'walletWithdrawal')
         currencyPrecision = self.parse_number(self.parse_precision(self.safe_string(rawCurrency, 'precision')))
         networks: dict = {}
         rawNetworks = self.safe_dict(rawCurrency, 'blockchains', {})
@@ -349,8 +347,8 @@ class cex(Exchange, ImplicitAPI):
             'name': None,
             'type': type,
             'active': None,
-            'deposit': currencyDepositEnabled,
-            'withdraw': currencyWithdrawEnabled,
+            'deposit': self.safe_bool(rawCurrency, 'walletDeposit'),
+            'withdraw': self.safe_bool(rawCurrency, 'walletWithdrawal'),
             'fee': None,
             'precision': currencyPrecision,
             'limits': {

ccxt/coinbase.py

@@ -1424,9 +1424,6 @@ class coinbase(Exchange, ImplicitAPI):
                 self.v3PublicGetBrokerageMarketProducts(self.extend(params, {'product_type': 'FUTURE'})),
                 self.v3PublicGetBrokerageMarketProducts(self.extend(params, {'product_type': 'FUTURE', 'contract_expiry_type': 'PERPETUAL'})),
             ]
-            if self.check_required_credentials(False):
-                unresolvedContractPromises.append(self.extend(params, {'product_type': 'FUTURE'}))
-                unresolvedContractPromises.append(self.extend(params, {'product_type': 'FUTURE', 'contract_expiry_type': 'PERPETUAL'}))
         except Exception as e:
             unresolvedContractPromises = []  # the sync version of ccxt won't have the promise.all line so the request is made here. Some users can't access perpetual products
         promises = spotUnresolvedPromises
@@ -1439,8 +1436,8 @@ class coinbase(Exchange, ImplicitAPI):
         fees = self.safe_dict(promises, 1, {})
         expiringFutures = self.safe_dict(contractPromises, 0, {})
         perpetualFutures = self.safe_dict(contractPromises, 1, {})
-        expiringFees = self.safe_dict(contractPromises, 2, {})
-        perpetualFees = self.safe_dict(contractPromises, 3, {})
+        expiringFees = self.safe_dict(contractPromises, 0, {})
+        perpetualFees = self.safe_dict(contractPromises, 1, {})
         #
         #     {
         #         "total_volume": 0,
@@ -1832,45 +1829,46 @@ class coinbase(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: an associative dictionary of currencies
         """
-        response = self.fetch_currencies_from_cache(params)
-        currencies = self.safe_list(response, 'currencies', [])
-        #
-        # fiat
-        #
-        #    {
-        #        id: 'IMP',
-        #        name: 'Isle of Man Pound',
-        #        min_size: '0.01'
-        #    },
-        #
-        # crypto
-        #
-        #    {
-        #        asset_id: '9476e3be-b731-47fa-82be-347fabc573d9',
-        #        code: 'AERO',
-        #        name: 'Aerodrome Finance',
-        #        color: '#0433FF',
-        #        sort_index: '340',
-        #        exponent: '8',
-        #        type: 'crypto',
-        #        address_regex: '^(?:0x)?[0-9a-fA-F]{40}$'
-        #    }
+        promises = [
+            self.v2PublicGetCurrencies(params),
+            self.v2PublicGetCurrenciesCrypto(params),
+            self.v2PublicGetExchangeRates(params),
+        ]
+        promisesResult = promises
+        fiatResponse = self.safe_dict(promisesResult, 0, {})
         #
+        #    [
+        #        "data": [
+        #            {
+        #                id: 'IMP',
+        #                name: 'Isle of Man Pound',
+        #                min_size: '0.01'
+        #            },
+        #        ...
         #
-        #     {
-        #         "data":{
-        #             "currency":"USD",
-        #             "rates":{
-        #                 "AED":"3.67",
-        #                 "AFN":"78.21",
-        #                 "ALL":"110.42",
-        #                 "AMD":"474.18",
-        #                 "ANG":"1.75",
-        #                 ...
-        #             },
-        #         }
-        #     }
+        cryptoResponse = self.safe_dict(promisesResult, 1, {})
         #
+        #     [
+        #        "data": [
+        #           {
+        #              asset_id: '9476e3be-b731-47fa-82be-347fabc573d9',
+        #              code: 'AERO',
+        #              name: 'Aerodrome Finance',
+        #              color: '#0433FF',
+        #              sort_index: '340',
+        #              exponent: '8',
+        #              type: 'crypto',
+        #              address_regex: '^(?:0x)?[0-9a-fA-F]{40}$'
+        #           },
+        #          ...
+        #
+        ratesResponse = self.safe_dict(promisesResult, 2, {})
+        fiatData = self.safe_list(fiatResponse, 'data', [])
+        cryptoData = self.safe_list(cryptoResponse, 'data', [])
+        ratesData = self.safe_dict(ratesResponse, 'data', {})
+        rates = self.safe_dict(ratesData, 'rates', {})
+        ratesIds = list(rates.keys())
+        currencies = self.array_concat(fiatData, cryptoData)
         result: dict = {}
         networks: dict = {}
         networksById: dict = {}
@@ -1882,18 +1880,19 @@ class coinbase(Exchange, ImplicitAPI):
             name = self.safe_string(currency, 'name')
             self.options['networks'][code] = name.lower()
             self.options['networksById'][code] = name.lower()
-            result[code] = {
-                'info': currency,  # the original payload
+            type = 'crypto' if (assetId is not None) else 'fiat'
+            result[code] = self.safe_currency_structure({
+                'info': currency,
                 'id': id,
                 'code': code,
-                'type': 'crypto' if (assetId is not None) else 'fiat',
-                'name': self.safe_string(currency, 'name'),
+                'type': type,
+                'name': name,
                 'active': True,
                 'deposit': None,
                 'withdraw': None,
                 'fee': None,
                 'precision': None,
-                'networks': {},
+                'networks': {},  # todo
                 'limits': {
                     'amount': {
                         'min': self.safe_number(currency, 'min_size'),
@@ -1904,11 +1903,23 @@ class coinbase(Exchange, ImplicitAPI):
                         'max': None,
                     },
                 },
-            }
+            })
             if assetId is not None:
                 lowerCaseName = name.lower()
                 networks[code] = lowerCaseName
                 networksById[lowerCaseName] = code
+        # we have to add other currencies here( https://discord.com/channels/1220414409550336183/1220464770239430761/1372215891940479098 )
+        for i in range(0, len(ratesIds)):
+            currencyId = ratesIds[i]
+            code = self.safe_currency_code(currencyId)
+            if not (code in result):
+                result[code] = self.safe_currency_structure({
+                    'info': {},
+                    'id': currencyId,
+                    'code': code,
+                    'type': 'crypto',
+                    'networks': {},  # todo
+                })
         self.options['networks'] = self.extend(networks, self.options['networks'])
         self.options['networksById'] = self.extend(networksById, self.options['networksById'])
         return result

ccxt/coinbaseexchange.py

@@ -307,6 +307,78 @@ class coinbaseexchange(Exchange, ImplicitAPI):
                     'inverse': None,
                 },
             },
+            'options': {
+                'networks': {
+                    'BTC': 'bitcoin',
+                    # LIGHTNING unsupported
+                    'ETH': 'ethereum',
+                    # TRON unsupported
+                    'SOL': 'solana',
+                    # BSC unsupported
+                    'ARBONE': 'arbitrum',
+                    'AVAXC': 'avacchain',
+                    'MATIC': 'polygon',
+                    'BASE': 'base',
+                    'SUI': 'sui',
+                    'OP': 'optimism',
+                    'NEAR': 'near',
+                    # CRONOS unsupported
+                    # GNO unsupported
+                    'APT': 'aptos',
+                    # SCROLL unsupported
+                    'KAVA': 'kava',
+                    # TAIKO unsupported
+                    # BOB unsupported
+                    # LINEA unsupported
+                    'BLAST': 'blast',
+                    'XLM': 'stellar',
+                    # RSK unsupported
+                    'SEI': 'sei',
+                    # TON unsupported
+                    # MANTLE unsupported
+                    'ADA': 'cardano',
+                    # HYPE unsupported
+                    'CORE': 'coredao',
+                    'ALGO': 'algorand',
+                    # RUNE unsupported
+                    'OSMO': 'osmosis',
+                    # XIN unsupported
+                    'CELO': 'celo',
+                    'HBAR': 'hedera',
+                    # FTM unsupported
+                    # WEMIX unsupported
+                    'ZKSYNC': 'zksync',
+                    # KLAY unsupported
+                    # HT unsupported
+                    # FSN unsupported
+                    # EOS unsupported, eosio?
+                    # ACA unsupported
+                    'STX': 'stacks',
+                    'XTZ': 'tezos',
+                    # NEO unsupported
+                    # METIS unsupported
+                    # TLOS unsupported
+                    'EGLD': 'elrond',
+                    # ASTR unsupported
+                    # CFX unsupported
+                    # GLMR unsupported
+                    # CANTO unsupported
+                    # SCRT unsupported
+                    'LTC': 'litecoin',
+                    # AURORA unsupported
+                    # ONG unsupported
+                    'ATOM': 'cosmos',
+                    # CHZ unsupported
+                    'FIL': 'filecoin',
+                    'DOT': 'polkadot',
+                    'DOGE': 'dogecoin',
+                    # BRC20 unsupported
+                    'XRP': 'ripple',
+                    # XMR unsupported
+                    'DASH': 'dash',
+                    # akash, aleo,  axelar, bitcoincash, berachain, deso, ethereumclassic, unichain, flow, flare, dfinity, story,kusama,  mina, ronin, oasis, bittensor, celestia, noble, vara, vechain, zcash, horizen, zetachain
+                },
+            },
             'exceptions': {
                 'exact': {
                     'Insufficient funds': InsufficientFunds,
@@ -342,30 +414,45 @@ class coinbaseexchange(Exchange, ImplicitAPI):
         """
         response = self.publicGetCurrencies(params)
         #
-        #     [
-        #         {
-        #             "id": "XTZ",
-        #             "name": "Tezos",
-        #             "min_size": "0.000001",
-        #             "status": "online",
-        #             "message": '',
-        #             "max_precision": "0.000001",
-        #             "convertible_to": [],
-        #             "details": {
-        #                 "type": "crypto",
-        #                 "symbol": "Τ",
-        #                 "network_confirmations": 60,
-        #                 "sort_order": 53,
-        #                 "crypto_address_link": "https://tzstats.com/{{address}}",
-        #                 "crypto_transaction_link": "https://tzstats.com/{{txId}}",
-        #                 "push_payment_methods": ["crypto"],
-        #                 "group_types": [],
-        #                 "display_name": '',
-        #                 "processing_time_seconds": 0,
-        #                 "min_withdrawal_amount": 1
-        #             }
-        #         }
-        #     ]
+        #   {
+        #     "id": "USDT",
+        #     "name": "Tether",
+        #     "min_size": "0.000001",
+        #     "status": "online",
+        #     "message": "",
+        #     "max_precision": "0.000001",
+        #     "convertible_to": [],
+        #     "details": {
+        #       "type": "crypto",
+        #       "symbol": null,
+        #       "network_confirmations": 14,
+        #       "sort_order": 0,
+        #       "crypto_address_link": "https://etherscan.io/token/0xdac17f958d2ee523a2206206994597c13d831ec7?a={{address}}",
+        #       "crypto_transaction_link": "https://etherscan.io/tx/0x{{txId}}",
+        #       "push_payment_methods": [],
+        #       "group_types": [],
+        #       "display_name": null,
+        #       "processing_time_seconds": null,
+        #       "min_withdrawal_amount": 0.000001,
+        #       "max_withdrawal_amount": 20000000
+        #     },
+        #     "default_network": "ethereum",
+        #     "supported_networks": [
+        #       {
+        #         "id": "ethereum",
+        #         "name": "Ethereum",
+        #         "status": "online",
+        #         "contract_address": "0xdac17f958d2ee523a2206206994597c13d831ec7",
+        #         "crypto_address_link": "https://etherscan.io/token/0xdac17f958d2ee523a2206206994597c13d831ec7?a={{address}}",
+        #         "crypto_transaction_link": "https://etherscan.io/tx/0x{{txId}}",
+        #         "min_withdrawal_amount": 0.000001,
+        #         "max_withdrawal_amount": 20000000,
+        #         "network_confirmations": 14,
+        #         "processing_time_seconds": null
+        #       }
+        #     ],
+        #     "display_name": "USDT"
+        #   }
         #
         result: dict = {}
         for i in range(0, len(response)):
@@ -373,16 +460,38 @@ class coinbaseexchange(Exchange, ImplicitAPI):
             id = self.safe_string(currency, 'id')
             name = self.safe_string(currency, 'name')
             code = self.safe_currency_code(id)
-            details = self.safe_value(currency, 'details', {})
-            status = self.safe_string(currency, 'status')
-            active = (status == 'online')
-            result[code] = {
+            details = self.safe_dict(currency, 'details', {})
+            networks: dict = {}
+            supportedNetworks = self.safe_list(currency, 'supported_networks', [])
+            for j in range(0, len(supportedNetworks)):
+                network = supportedNetworks[j]
+                networkId = self.safe_string(network, 'id')
+                networkCode = self.network_id_to_code(networkId)
+                networks[networkCode] = {
+                    'id': networkId,
+                    'name': self.safe_string(network, 'name'),
+                    'network': networkCode,
+                    'active': self.safe_string(network, 'status') == 'online',
+                    'withdraw': None,
+                    'deposit': None,
+                    'fee': None,
+                    'precision': None,
+                    'limits': {
+                        'withdraw': {
+                            'min': self.safe_number(network, 'min_withdrawal_amount'),
+                            'max': self.safe_number(network, 'max_withdrawal_amount'),
+                        },
+                    },
+                    'contract': self.safe_string(network, 'contract_address'),
+                    'info': network,
+                }
+            result[code] = self.safe_currency_structure({
                 'id': id,
                 'code': code,
                 'info': currency,
                 'type': self.safe_string(details, 'type'),
                 'name': name,
-                'active': active,
+                'active': self.safe_string(currency, 'status') == 'online',
                 'deposit': None,
                 'withdraw': None,
                 'fee': None,
@@ -394,11 +503,11 @@ class coinbaseexchange(Exchange, ImplicitAPI):
                     },
                     'withdraw': {
                         'min': self.safe_number(details, 'min_withdrawal_amount'),
-                        'max': None,
+                        'max': self.safe_number(details, 'max_withdrawal_amount'),
                     },
                 },
-                'networks': {},
-            }
+                'networks': networks,
+            })
         return result
 
     def fetch_markets(self, params={}) -> List[Market]: