ccxt 4.4.82 → 4.4.85

package/dist/cjs/src/coinbaseexchange.js

@@ -296,6 +296,78 @@ class coinbaseexchange extends coinbaseexchange$1 {
                     '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': errors.InsufficientFunds,
@@ -331,30 +403,45 @@ class coinbaseexchange extends coinbaseexchange$1 {
     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++) {
@@ -362,16 +449,39 @@ class coinbaseexchange extends coinbaseexchange$1 {
             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,
@@ -383,11 +493,11 @@ class coinbaseexchange extends coinbaseexchange$1 {
                     },
                     'withdraw': {
                         'min': this.safeNumber(details, 'min_withdrawal_amount'),
-                        'max': undefined,
+                        'max': this.safeNumber(details, 'max_withdrawal_amount'),
                     },
                 },
-                'networks': {},
-            };
+                'networks': networks,
+            });
         }
         return result;
     }

package/dist/cjs/src/coincatch.js

@@ -358,56 +358,18 @@ class coincatch extends coincatch$1 {
                     '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
                 },
             },
@@ -641,72 +603,57 @@ class coincatch extends coincatch$1 {
             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["default"].stringMin(networkMinDeposit, minDeposit) : networkMinDeposit;
-                minWithdraw = minWithdraw ? Precise["default"].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/dist/cjs/src/coinex.js

@@ -721,33 +721,6 @@ class coinex extends coinex$1 {
             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,
-            };
             for (let j = 0; j < chains.length; j++) {
                 const chain = chains[j];
                 const networkId = this.safeString(chain, 'chain');
@@ -760,7 +733,7 @@ class coinex extends coinex$1 {
                 const minNetworkWithdrawString = this.safeString(chain, 'min_withdraw_amount');
                 const canDepositChain = this.safeBool(chain, 'deposit_enabled');
                 const canWithdrawChain = this.safeBool(chain, 'withdraw_enabled');
-                const network = {
+                ({
                     'id': networkId,
                     'network': networkId,
                     'name': undefined,
@@ -784,11 +757,35 @@ class coinex extends coinex$1 {
                         },
                     },
                     '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/dist/cjs/src/coinlist.js

@@ -453,30 +453,31 @@ class coinlist extends coinlist$1 {
             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;
     }

package/dist/cjs/src/coinmetro.js

@@ -377,24 +377,35 @@ class coinmetro extends coinmetro$1 {
             const currency = response[i];
             const id = this.safeString(currency, 'symbol');
             const code = this.safeCurrencyCode(id);
-            const withdraw = this.safeValue(currency, 'canWithdraw');
-            const deposit = this.safeValue(currency, 'canDeposit');
-            const canTrade = this.safeValue(currency, 'canTrade');
-            const active = canTrade ? withdraw : true;
-            const minAmount = this.safeNumber(currency, 'minQty');
+            const typeRaw = this.safeString(currency, 'type');
+            let type = undefined;
+            if (typeRaw === 'coin' || typeRaw === 'token' || typeRaw === 'erc20') {
+                type = 'crypto';
+            }
+            else if (typeRaw === 'fiat') {
+                type = 'fiat';
+            }
+            const precisionDigits = this.safeString2(currency, 'digits', 'notabeneDecimals');
             result[code] = this.safeCurrencyStructure({
                 'id': id,
                 'code': code,
                 'name': code,
+                'type': type,
                 'info': currency,
-                'active': active,
-                'deposit': deposit,
-                'withdraw': withdraw,
+                'active': this.safeBool(currency, 'canTrade'),
+                'deposit': this.safeBool(currency, 'canDeposit'),
+                'withdraw': this.safeBool(currency, 'canWithdraw'),
                 'fee': undefined,
-                'precision': this.parseNumber(this.parsePrecision(this.safeString(currency, 'digits'))),
+                'precision': this.parseNumber(this.parsePrecision(precisionDigits)),
                 'limits': {
-                    'amount': { 'min': minAmount, 'max': undefined },
-                    'withdraw': { 'min': undefined, 'max': undefined },
+                    'amount': {
+                        'min': this.safeNumber(currency, 'minQty'),
+                        'max': undefined,
+                    },
+                    'withdraw': {
+                        'min': undefined,
+                        'max': undefined,
+                    },
                 },
                 'networks': {},
             });

package/dist/cjs/src/coinone.js

@@ -296,18 +296,16 @@ class coinone extends coinone$1 {
         for (let i = 0; i < currencies.length; i++) {
             const entry = currencies[i];
             const id = this.safeString(entry, 'symbol');
-            const name = this.safeString(entry, 'name');
             const code = this.safeCurrencyCode(id);
-            const withdrawStatus = this.safeString(entry, 'withdraw_status', '');
-            const depositStatus = this.safeString(entry, 'deposit_status', '');
-            const isWithdrawEnabled = withdrawStatus === 'normal';
-            const isDepositEnabled = depositStatus === 'normal';
-            result[code] = {
+            const isWithdrawEnabled = this.safeString(entry, 'withdraw_status', '') === 'normal';
+            const isDepositEnabled = this.safeString(entry, 'deposit_status', '') === 'normal';
+            const type = (code !== 'KRW') ? 'crypto' : 'fiat';
+            result[code] = this.safeCurrencyStructure({
                 'id': id,
                 'code': code,
                 'info': entry,
-                'name': name,
-                'active': isWithdrawEnabled && isDepositEnabled,
+                'name': this.safeString(entry, 'name'),
+                'active': undefined,
                 'deposit': isDepositEnabled,
                 'withdraw': isWithdrawEnabled,
                 'fee': this.safeNumber(entry, 'withdrawal_fee'),
@@ -323,8 +321,8 @@ class coinone extends coinone$1 {
                     },
                 },
                 'networks': {},
-                'type': 'crypto',
-            };
+                'type': type,
+            });
         }
         return result;
     }