ccxt 4.4.80__py2.py3-none-any.whl → 4.4.85__py2.py3-none-any.whl

ccxt/async_support/coinbase.py

@@ -1833,45 +1833,46 @@ class coinbase(Exchange, ImplicitAPI):
         :param dict [params]: extra parameters specific to the exchange API endpoint
         :returns dict: an associative dictionary of currencies
         """
-        response = await 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 = await asyncio.gather(*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 = {}
@@ -1883,18 +1884,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'),
@@ -1905,11 +1907,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/async_support/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 = await 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
 
     async def fetch_markets(self, params={}) -> List[Market]:

ccxt/async_support/coincatch.py

@@ -375,56 +375,18 @@ class coincatch(Exchange, ImplicitAPI):
                     'CRO': 'CronosChain',
                 },
                 'networksById': {
-                    'BITCOIN': 'BTC',
-                    'ERC20': 'ERC20',
                     'TRC20': 'TRC20',
                     'TRX(TRC20)': 'TRC20',
-                    'BEP20': 'BEP20',
                     'ArbitrumOne': 'ARB',  # todo check
-                    'Optimism': 'OPTIMISM',
-                    'LTC': 'LTC',
-                    'BCH': 'BCH',
-                    'ETC': 'ETC',
-                    'SOL': 'SOL',
-                    'NEO3': 'NEO3',
-                    'stacks': 'STX',
-                    'Elrond': 'EGLD',
-                    'NEARProtocol': 'NEAR',
-                    'AcalaToken': 'ACA',
-                    'Klaytn': 'KLAY',
-                    'Fantom': 'FTM',
-                    'Terra': 'TERRA',
-                    'WAVES': 'WAVES',
-                    'TAO': 'TAO',
-                    'SUI': 'SUI',
-                    'SEI': 'SEI',
                     'THORChain': 'RUNE',  # todo check
-                    'ZIL': 'ZIL',
                     'Solar': 'SXP',  # todo check
-                    'FET': 'FET',
                     'C-Chain': 'AVAX',  # todo check
-                    'XRP': 'XRP',
-                    'EOS': 'EOS',
-                    'DOGECOIN': 'DOGE',
                     'CAP20': 'CAP20',  # todo check
-                    'Polygon': 'MATIC',
-                    'CSPR': 'CSPR',
-                    'Moonbeam': 'GLMR',
-                    'MINA': 'MINA',
                     'CFXeSpace': 'CFX',  # todo check
                     'CFX': 'CFX',
                     'StratisEVM': 'STRAT',  # todo check
-                    'Celestia': 'TIA',
                     'ChilizChain': 'ChilizChain',  # todo check
-                    'Aptos': 'APT',
-                    'Ontology': 'ONT',
-                    'ICP': 'ICP',
-                    'Cardano': 'ADA',
-                    'FIL': 'FIL',
-                    'CELO': 'CELO',
-                    'DOT': 'DOT',
                     'StellarLumens': 'XLM',  # todo check
-                    'ATOM': 'ATOM',
                     'CronosChain': 'CRO',  # todo check
                 },
             },
@@ -656,71 +618,56 @@ class coincatch(Exchange, ImplicitAPI):
             currencyId = self.safe_string(currecy, 'coinName')
             currenciesIds.append(currencyId)
             code = self.safe_currency_code(currencyId)
-            allowDeposit = False
-            allowWithdraw = False
-            minDeposit: Str = None
-            minWithdraw: Str = None
             networks = self.safe_list(currecy, 'chains')
-            networksById = self.safe_dict(self.options, 'networksById')
             parsedNetworks: dict = {}
             for j in range(0, len(networks)):
                 network = networks[j]
                 networkId = self.safe_string(network, 'chain')
-                networkName = self.safe_string(networksById, networkId, networkId)
-                networkDepositString = self.safe_string(network, 'rechargeable')
-                networkDeposit = networkDepositString == 'true'
-                networkWithdrawString = self.safe_string(network, 'withdrawable')
-                networkWithdraw = networkWithdrawString == 'true'
-                networkMinDeposit = self.safe_string(network, 'minDepositAmount')
-                networkMinWithdraw = self.safe_string(network, 'minWithdrawAmount')
+                networkCode = self.network_code_to_id(networkId)
                 parsedNetworks[networkId] = {
                     'id': networkId,
-                    'network': networkName,
+                    'network': networkCode,
                     'limits': {
                         'deposit': {
-                            'min': self.parse_number(networkMinDeposit),
+                            'min': self.safe_number(network, 'minDepositAmount'),
                             'max': None,
                         },
                         'withdraw': {
-                            'min': self.parse_number(networkMinWithdraw),
+                            'min': self.safe_number(network, 'minWithdrawAmount'),
                             'max': None,
                         },
                     },
-                    'active': networkDeposit and networkWithdraw,
-                    'deposit': networkDeposit,
-                    'withdraw': networkWithdraw,
+                    'active': None,
+                    'deposit': self.safe_string(network, 'rechargeable') == 'true',
+                    'withdraw': self.safe_string(network, 'withdrawable') == 'true',
                     'fee': self.safe_number(network, 'withdrawFee'),
                     'precision': None,
                     'info': network,
                 }
-                allowDeposit = allowDeposit if allowDeposit else networkDeposit
-                allowWithdraw = allowWithdraw if allowWithdraw else networkWithdraw
-                minDeposit = Precise.string_min(networkMinDeposit, minDeposit) if minDeposit else networkMinDeposit
-                minWithdraw = Precise.string_min(networkMinWithdraw, minWithdraw) if minWithdraw else networkMinWithdraw
-            result[code] = {
+            result[code] = self.safe_currency_structure({
                 'id': currencyId,
                 'numericId': self.safe_integer(currecy, 'coinId'),
                 'code': code,
                 'precision': None,
                 'type': None,
                 'name': None,
-                'active': allowWithdraw and allowDeposit,
-                'deposit': allowDeposit,
-                'withdraw': allowWithdraw,
+                'active': None,
+                'deposit': None,
+                'withdraw': None,
                 'fee': None,
                 'limits': {
                     'deposit': {
-                        'min': self.parse_number(minDeposit),
+                        'min': None,
                         'max': None,
                     },
                     'withdraw': {
-                        'min': self.parse_number(minWithdraw),
+                        'min': None,
                         'max': None,
                     },
                 },
                 'networks': parsedNetworks,
                 'info': currecy,
-            }
+            })
         if self.safe_list(self.options, 'currencyIdsListForParseMarket') is None:
             self.options['currencyIdsListForParseMarket'] = currenciesIds
         return result

ccxt/async_support/coinex.py

@@ -734,33 +734,7 @@ class coinex(Exchange, ImplicitAPI):
             canWithdraw = self.safe_bool(asset, 'withdraw_enabled')
             firstChain = self.safe_dict(chains, 0, {})
             firstPrecisionString = self.parse_precision(self.safe_string(firstChain, 'withdrawal_precision'))
-            result[code] = {
-                'id': currencyId,
-                'code': code,
-                'name': None,
-                'active': canDeposit and canWithdraw,
-                'deposit': canDeposit,
-                'withdraw': canWithdraw,
-                'fee': None,
-                'precision': self.parse_number(firstPrecisionString),
-                'limits': {
-                    'amount': {
-                        'min': None,
-                        'max': None,
-                    },
-                    'deposit': {
-                        'min': None,
-                        'max': None,
-                    },
-                    'withdraw': {
-                        'min': None,
-                        'max': None,
-                    },
-                },
-                'networks': {},
-                'type': 'crypto',
-                'info': coin,
-            }
+            networks: dict = {}
             for j in range(0, len(chains)):
                 chain = chains[j]
                 networkId = self.safe_string(chain, 'chain')
@@ -797,9 +771,34 @@ class coinex(Exchange, ImplicitAPI):
                     },
                     'info': chain,
                 }
-                networks = self.safe_dict(result[code], 'networks', {})
                 networks[networkId] = network
-                result[code]['networks'] = networks
+            result[code] = self.safe_currency_structure({
+                'id': currencyId,
+                'code': code,
+                'name': None,
+                'active': canDeposit and canWithdraw,
+                'deposit': canDeposit,
+                'withdraw': canWithdraw,
+                'fee': None,
+                'precision': self.parse_number(firstPrecisionString),
+                'limits': {
+                    'amount': {
+                        'min': None,
+                        'max': None,
+                    },
+                    'deposit': {
+                        'min': None,
+                        'max': None,
+                    },
+                    'withdraw': {
+                        'min': None,
+                        'max': None,
+                    },
+                },
+                'networks': {},
+                'type': 'crypto',
+                'info': coin,
+            })
         return result
 
     async def fetch_markets(self, params={}) -> List[Market]:

ccxt/async_support/coinlist.py

@@ -467,30 +467,31 @@ class coinlist(Exchange, ImplicitAPI):
             currency = currencies[i]
             id = self.safe_string(currency, 'asset')
             code = self.safe_currency_code(id)
+            isFiat = code == 'USD'
             isTransferable = self.safe_bool(currency, 'is_transferable', False)
-            withdrawEnabled = isTransferable
-            depositEnabled = isTransferable
-            active = isTransferable
-            decimalPlaces = self.safe_string(currency, 'decimal_places')
-            precision = self.parse_number(self.parse_precision(decimalPlaces))
-            minWithdrawal = self.safe_string(currency, 'min_withdrawal')
-            result[code] = {
+            result[code] = self.safe_currency_structure({
                 'id': id,
                 'code': code,
                 'name': code,
                 'info': currency,
-                'active': active,
-                'deposit': depositEnabled,
-                'withdraw': withdrawEnabled,
+                'active': None,
+                'deposit': isTransferable,
+                'withdraw': isTransferable,
                 'fee': None,
-                'precision': precision,
+                'precision': self.parse_number(self.parse_precision(self.safe_string(currency, 'decimal_places'))),
                 'limits': {
-                    'amount': {'min': None, 'max': None},
-                    'withdraw': {'min': minWithdrawal, 'max': None},
+                    'amount': {
+                        'min': None,
+                        'max': None,
+                    },
+                    'withdraw': {
+                        'min': self.safe_number(currency, 'min_withdrawal'),
+                        'max': None,
+                    },
                 },
-                'networks': {},
-                'type': 'crypto',
-            }
+                'networks': {},  # todo
+                'type': 'fiat' if isFiat else 'crypto',
+            })
         return result
 
     async def fetch_markets(self, params={}) -> List[Market]:

ccxt/async_support/coinmetro.py

@@ -387,24 +387,33 @@ class coinmetro(Exchange, ImplicitAPI):
             currency = response[i]
             id = self.safe_string(currency, 'symbol')
             code = self.safe_currency_code(id)
-            withdraw = self.safe_value(currency, 'canWithdraw')
-            deposit = self.safe_value(currency, 'canDeposit')
-            canTrade = self.safe_value(currency, 'canTrade')
-            active = withdraw if canTrade else True
-            minAmount = self.safe_number(currency, 'minQty')
+            typeRaw = self.safe_string(currency, 'type')
+            type = None
+            if typeRaw == 'coin' or typeRaw == 'token' or typeRaw == 'erc20':
+                type = 'crypto'
+            elif typeRaw == 'fiat':
+                type = 'fiat'
+            precisionDigits = self.safe_string_2(currency, 'digits', 'notabeneDecimals')
             result[code] = self.safe_currency_structure({
                 'id': id,
                 'code': code,
                 'name': code,
+                'type': type,
                 'info': currency,
-                'active': active,
-                'deposit': deposit,
-                'withdraw': withdraw,
+                'active': self.safe_bool(currency, 'canTrade'),
+                'deposit': self.safe_bool(currency, 'canDeposit'),
+                'withdraw': self.safe_bool(currency, 'canWithdraw'),
                 'fee': None,
-                'precision': self.parse_number(self.parse_precision(self.safe_string(currency, 'digits'))),
+                'precision': self.parse_number(self.parse_precision(precisionDigits)),
                 'limits': {
-                    'amount': {'min': minAmount, 'max': None},
-                    'withdraw': {'min': None, 'max': None},
+                    'amount': {
+                        'min': self.safe_number(currency, 'minQty'),
+                        'max': None,
+                    },
+                    'withdraw': {
+                        'min': None,
+                        'max': None,
+                    },
                 },
                 'networks': {},
             })