ccxt 4.4.82 → 4.4.86

package/js/src/coinbase.js

@@ -1455,10 +1455,6 @@ export default class coinbase extends Exchange {
                 this.v3PublicGetBrokerageMarketProducts(this.extend(params, { 'product_type': 'FUTURE' })),
                 this.v3PublicGetBrokerageMarketProducts(this.extend(params, { 'product_type': 'FUTURE', 'contract_expiry_type': 'PERPETUAL' })),
             ];
-            if (this.checkRequiredCredentials(false)) {
-                unresolvedContractPromises.push(this.extend(params, { 'product_type': 'FUTURE' }));
-                unresolvedContractPromises.push(this.extend(params, { 'product_type': 'FUTURE', 'contract_expiry_type': 'PERPETUAL' }));
-            }
         }
         catch (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
@@ -1475,8 +1471,8 @@ export default class coinbase extends Exchange {
         const fees = this.safeDict(promises, 1, {});
         const expiringFutures = this.safeDict(contractPromises, 0, {});
         const perpetualFutures = this.safeDict(contractPromises, 1, {});
-        const expiringFees = this.safeDict(contractPromises, 2, {});
-        const perpetualFees = this.safeDict(contractPromises, 3, {});
+        const expiringFees = this.safeDict(contractPromises, 0, {});
+        const perpetualFees = this.safeDict(contractPromises, 1, {});
         //
         //     {
         //         "total_volume": 0,
@@ -1877,45 +1873,46 @@ export default class coinbase extends Exchange {
      * @returns {object} an associative dictionary of currencies
      */
     async fetchCurrencies(params = {}) {
-        const response = await this.fetchCurrenciesFromCache(params);
-        const currencies = this.safeList(response, 'currencies', []);
-        //
-        // fiat
-        //
-        //    {
-        //        id: 'IMP',
-        //        name: 'Isle of Man Pound',
-        //        min_size: '0.01'
-        //    },
-        //
-        // crypto
+        const promises = [
+            this.v2PublicGetCurrencies(params),
+            this.v2PublicGetCurrenciesCrypto(params),
+            this.v2PublicGetExchangeRates(params),
+        ];
+        const promisesResult = await Promise.all(promises);
+        const fiatResponse = this.safeDict(promisesResult, 0, {});
         //
-        //    {
-        //        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}$'
-        //    }
+        //    [
+        //        "data": [
+        //            {
+        //                id: 'IMP',
+        //                name: 'Isle of Man Pound',
+        //                min_size: '0.01'
+        //            },
+        //        ...
         //
+        const cryptoResponse = this.safeDict(promisesResult, 1, {});
         //
-        //     {
-        //         "data":{
-        //             "currency":"USD",
-        //             "rates":{
-        //                 "AED":"3.67",
-        //                 "AFN":"78.21",
-        //                 "ALL":"110.42",
-        //                 "AMD":"474.18",
-        //                 "ANG":"1.75",
-        //                 ...
-        //             },
-        //         }
-        //     }
-        //
+        //     [
+        //        "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}$'
+        //           },
+        //          ...
+        //
+        const ratesResponse = this.safeDict(promisesResult, 2, {});
+        const fiatData = this.safeList(fiatResponse, 'data', []);
+        const cryptoData = this.safeList(cryptoResponse, 'data', []);
+        const ratesData = this.safeDict(ratesResponse, 'data', {});
+        const rates = this.safeDict(ratesData, 'rates', {});
+        const ratesIds = Object.keys(rates);
+        const currencies = this.arrayConcat(fiatData, cryptoData);
         const result = {};
         const networks = {};
         const networksById = {};
@@ -1927,12 +1924,13 @@ export default class coinbase extends Exchange {
             const name = this.safeString(currency, 'name');
             this.options['networks'][code] = name.toLowerCase();
             this.options['networksById'][code] = name.toLowerCase();
-            result[code] = {
+            const type = (assetId !== undefined) ? 'crypto' : 'fiat';
+            result[code] = this.safeCurrencyStructure({
                 'info': currency,
                 'id': id,
                 'code': code,
-                'type': (assetId !== undefined) ? 'crypto' : 'fiat',
-                'name': this.safeString(currency, 'name'),
+                'type': type,
+                'name': name,
                 'active': true,
                 'deposit': undefined,
                 'withdraw': undefined,
@@ -1949,13 +1947,27 @@ export default class coinbase extends Exchange {
                         'max': undefined,
                     },
                 },
-            };
+            });
             if (assetId !== undefined) {
                 const lowerCaseName = name.toLowerCase();
                 networks[code] = lowerCaseName;
                 networksById[lowerCaseName] = code;
             }
         }
+        // we have to add other currencies here ( https://discord.com/channels/1220414409550336183/1220464770239430761/1372215891940479098 )
+        for (let i = 0; i < ratesIds.length; i++) {
+            const currencyId = ratesIds[i];
+            const code = this.safeCurrencyCode(currencyId);
+            if (!(code in result)) {
+                result[code] = this.safeCurrencyStructure({
+                    'info': {},
+                    'id': currencyId,
+                    'code': code,
+                    'type': 'crypto',
+                    'networks': {}, // todo
+                });
+            }
+        }
         this.options['networks'] = this.extend(networks, this.options['networks']);
         this.options['networksById'] = this.extend(networksById, this.options['networksById']);
         return result;

package/js/src/coinbaseexchange.js

@@ -299,6 +299,78 @@ export default class coinbaseexchange extends Exchange {
                     'inverse': undefined,
                 },
             },
+            '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,
@@ -334,30 +406,45 @@ export default class coinbaseexchange extends Exchange {
     async fetchCurrencies(params = {}) {
         const response = await this.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"
+        //   }
         //
         const result = {};
         for (let i = 0; i < response.length; i++) {
@@ -365,16 +452,39 @@ export default class coinbaseexchange extends Exchange {
             const id = this.safeString(currency, 'id');
             const name = this.safeString(currency, 'name');
             const code = this.safeCurrencyCode(id);
-            const details = this.safeValue(currency, 'details', {});
-            const status = this.safeString(currency, 'status');
-            const active = (status === 'online');
-            result[code] = {
+            const details = this.safeDict(currency, 'details', {});
+            const networks = {};
+            const supportedNetworks = this.safeList(currency, 'supported_networks', []);
+            for (let j = 0; j < supportedNetworks.length; j++) {
+                const network = supportedNetworks[j];
+                const networkId = this.safeString(network, 'id');
+                const networkCode = this.networkIdToCode(networkId);
+                networks[networkCode] = {
+                    'id': networkId,
+                    'name': this.safeString(network, 'name'),
+                    'network': networkCode,
+                    'active': this.safeString(network, 'status') === 'online',
+                    'withdraw': undefined,
+                    'deposit': undefined,
+                    'fee': undefined,
+                    'precision': undefined,
+                    'limits': {
+                        'withdraw': {
+                            'min': this.safeNumber(network, 'min_withdrawal_amount'),
+                            'max': this.safeNumber(network, 'max_withdrawal_amount'),
+                        },
+                    },
+                    'contract': this.safeString(network, 'contract_address'),
+                    'info': network,
+                };
+            }
+            result[code] = this.safeCurrencyStructure({
                 'id': id,
                 'code': code,
                 'info': currency,
                 'type': this.safeString(details, 'type'),
                 'name': name,
-                'active': active,
+                'active': this.safeString(currency, 'status') === 'online',
                 'deposit': undefined,
                 'withdraw': undefined,
                 'fee': undefined,
@@ -386,11 +496,11 @@ export default class coinbaseexchange extends Exchange {
                     },
                     'withdraw': {
                         'min': this.safeNumber(details, 'min_withdrawal_amount'),
-                        'max': undefined,
+                        'max': this.safeNumber(details, 'max_withdrawal_amount'),
                     },
                 },
-                'networks': {},
-            };
+                'networks': networks,
+            });
         }
         return result;
     }

package/js/src/coincatch.js

@@ -361,56 +361,18 @@ export default class coincatch extends Exchange {
                     'CRO': 'CronosChain',
                 },
                 'networksById': {
-                    'BITCOIN': 'BTC',
-                    'ERC20': 'ERC20',
                     'TRC20': 'TRC20',
                     'TRX(TRC20)': 'TRC20',
-                    'BEP20': 'BEP20',
                     'ArbitrumOne': 'ARB',
-                    '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',
-                    'ZIL': 'ZIL',
                     'Solar': 'SXP',
-                    'FET': 'FET',
                     'C-Chain': 'AVAX',
-                    'XRP': 'XRP',
-                    'EOS': 'EOS',
-                    'DOGECOIN': 'DOGE',
                     'CAP20': 'CAP20',
-                    'Polygon': 'MATIC',
-                    'CSPR': 'CSPR',
-                    'Moonbeam': 'GLMR',
-                    'MINA': 'MINA',
                     'CFXeSpace': 'CFX',
                     'CFX': 'CFX',
                     'StratisEVM': 'STRAT',
-                    'Celestia': 'TIA',
                     'ChilizChain': 'ChilizChain',
-                    'Aptos': 'APT',
-                    'Ontology': 'ONT',
-                    'ICP': 'ICP',
-                    'Cardano': 'ADA',
-                    'FIL': 'FIL',
-                    'CELO': 'CELO',
-                    'DOT': 'DOT',
                     'StellarLumens': 'XLM',
-                    'ATOM': 'ATOM',
                     'CronosChain': 'CRO', // todo check
                 },
             },
@@ -644,72 +606,57 @@ export default class coincatch extends Exchange {
             const currencyId = this.safeString(currecy, 'coinName');
             currenciesIds.push(currencyId);
             const code = this.safeCurrencyCode(currencyId);
-            let allowDeposit = false;
-            let allowWithdraw = false;
-            let minDeposit = undefined;
-            let minWithdraw = undefined;
             const networks = this.safeList(currecy, 'chains');
-            const networksById = this.safeDict(this.options, 'networksById');
             const parsedNetworks = {};
             for (let j = 0; j < networks.length; j++) {
                 const network = networks[j];
                 const networkId = this.safeString(network, 'chain');
-                const networkName = this.safeString(networksById, networkId, networkId);
-                const networkDepositString = this.safeString(network, 'rechargeable');
-                const networkDeposit = networkDepositString === 'true';
-                const networkWithdrawString = this.safeString(network, 'withdrawable');
-                const networkWithdraw = networkWithdrawString === 'true';
-                const networkMinDeposit = this.safeString(network, 'minDepositAmount');
-                const networkMinWithdraw = this.safeString(network, 'minWithdrawAmount');
+                const networkCode = this.networkCodeToId(networkId);
                 parsedNetworks[networkId] = {
                     'id': networkId,
-                    'network': networkName,
+                    'network': networkCode,
                     'limits': {
                         'deposit': {
-                            'min': this.parseNumber(networkMinDeposit),
+                            'min': this.safeNumber(network, 'minDepositAmount'),
                             'max': undefined,
                         },
                         'withdraw': {
-                            'min': this.parseNumber(networkMinWithdraw),
+                            'min': this.safeNumber(network, 'minWithdrawAmount'),
                             'max': undefined,
                         },
                     },
-                    'active': networkDeposit && networkWithdraw,
-                    'deposit': networkDeposit,
-                    'withdraw': networkWithdraw,
+                    'active': undefined,
+                    'deposit': this.safeString(network, 'rechargeable') === 'true',
+                    'withdraw': this.safeString(network, 'withdrawable') === 'true',
                     'fee': this.safeNumber(network, 'withdrawFee'),
                     'precision': undefined,
                     'info': network,
                 };
-                allowDeposit = allowDeposit ? allowDeposit : networkDeposit;
-                allowWithdraw = allowWithdraw ? allowWithdraw : networkWithdraw;
-                minDeposit = minDeposit ? Precise.stringMin(networkMinDeposit, minDeposit) : networkMinDeposit;
-                minWithdraw = minWithdraw ? Precise.stringMin(networkMinWithdraw, minWithdraw) : networkMinWithdraw;
             }
-            result[code] = {
+            result[code] = this.safeCurrencyStructure({
                 'id': currencyId,
                 'numericId': this.safeInteger(currecy, 'coinId'),
                 'code': code,
                 'precision': undefined,
                 'type': undefined,
                 'name': undefined,
-                'active': allowWithdraw && allowDeposit,
-                'deposit': allowDeposit,
-                'withdraw': allowWithdraw,
+                'active': undefined,
+                'deposit': undefined,
+                'withdraw': undefined,
                 'fee': undefined,
                 'limits': {
                     'deposit': {
-                        'min': this.parseNumber(minDeposit),
+                        'min': undefined,
                         'max': undefined,
                     },
                     'withdraw': {
-                        'min': this.parseNumber(minWithdraw),
+                        'min': undefined,
                         'max': undefined,
                     },
                 },
                 'networks': parsedNetworks,
                 'info': currecy,
-            };
+            });
         }
         if (this.safeList(this.options, 'currencyIdsListForParseMarket') === undefined) {
             this.options['currencyIdsListForParseMarket'] = currenciesIds;

package/js/src/coinex.js

@@ -724,33 +724,7 @@ export default class coinex extends Exchange {
             const canWithdraw = this.safeBool(asset, 'withdraw_enabled');
             const firstChain = this.safeDict(chains, 0, {});
             const firstPrecisionString = this.parsePrecision(this.safeString(firstChain, 'withdrawal_precision'));
-            result[code] = {
-                'id': currencyId,
-                'code': code,
-                'name': undefined,
-                'active': canDeposit && canWithdraw,
-                'deposit': canDeposit,
-                'withdraw': canWithdraw,
-                'fee': undefined,
-                'precision': this.parseNumber(firstPrecisionString),
-                'limits': {
-                    'amount': {
-                        'min': undefined,
-                        'max': undefined,
-                    },
-                    'deposit': {
-                        'min': undefined,
-                        'max': undefined,
-                    },
-                    'withdraw': {
-                        'min': undefined,
-                        'max': undefined,
-                    },
-                },
-                'networks': {},
-                'type': 'crypto',
-                'info': coin,
-            };
+            const networks = {};
             for (let j = 0; j < chains.length; j++) {
                 const chain = chains[j];
                 const networkId = this.safeString(chain, 'chain');
@@ -788,10 +762,35 @@ export default class coinex extends Exchange {
                     },
                     'info': chain,
                 };
-                const networks = this.safeDict(result[code], 'networks', {});
                 networks[networkId] = network;
-                result[code]['networks'] = networks;
             }
+            result[code] = this.safeCurrencyStructure({
+                'id': currencyId,
+                'code': code,
+                'name': undefined,
+                'active': canDeposit && canWithdraw,
+                'deposit': canDeposit,
+                'withdraw': canWithdraw,
+                'fee': undefined,
+                'precision': this.parseNumber(firstPrecisionString),
+                'limits': {
+                    'amount': {
+                        'min': undefined,
+                        'max': undefined,
+                    },
+                    'deposit': {
+                        'min': undefined,
+                        'max': undefined,
+                    },
+                    'withdraw': {
+                        'min': undefined,
+                        'max': undefined,
+                    },
+                },
+                'networks': {},
+                'type': 'crypto',
+                'info': coin,
+            });
         }
         return result;
     }

package/js/src/coinlist.js

@@ -455,30 +455,31 @@ export default class coinlist extends Exchange {
             const currency = currencies[i];
             const id = this.safeString(currency, 'asset');
             const code = this.safeCurrencyCode(id);
+            const isFiat = code === 'USD';
             const isTransferable = this.safeBool(currency, 'is_transferable', false);
-            const withdrawEnabled = isTransferable;
-            const depositEnabled = isTransferable;
-            const active = isTransferable;
-            const decimalPlaces = this.safeString(currency, 'decimal_places');
-            const precision = this.parseNumber(this.parsePrecision(decimalPlaces));
-            const minWithdrawal = this.safeString(currency, 'min_withdrawal');
-            result[code] = {
+            result[code] = this.safeCurrencyStructure({
                 'id': id,
                 'code': code,
                 'name': code,
                 'info': currency,
-                'active': active,
-                'deposit': depositEnabled,
-                'withdraw': withdrawEnabled,
+                'active': undefined,
+                'deposit': isTransferable,
+                'withdraw': isTransferable,
                 'fee': undefined,
-                'precision': precision,
+                'precision': this.parseNumber(this.parsePrecision(this.safeString(currency, 'decimal_places'))),
                 'limits': {
-                    'amount': { 'min': undefined, 'max': undefined },
-                    'withdraw': { 'min': minWithdrawal, 'max': undefined },
+                    'amount': {
+                        'min': undefined,
+                        'max': undefined,
+                    },
+                    'withdraw': {
+                        'min': this.safeNumber(currency, 'min_withdrawal'),
+                        'max': undefined,
+                    },
                 },
                 'networks': {},
-                'type': 'crypto',
-            };
+                'type': isFiat ? 'fiat' : 'crypto',
+            });
         }
         return result;
     }