ccxt 4.5.56 → 4.5.58

package/dist/cjs/src/coinex.js

@@ -9,7 +9,7 @@ var number = require('./base/functions/number.js');
 var sha256 = require('./static_dependencies/noble-hashes/sha256.js');
 var md5 = require('./static_dependencies/noble-hashes/md5.js');
 
-//  ---------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 //  ---------------------------------------------------------------------------
 /**
  * @class coinex
@@ -730,90 +730,88 @@ class coinex extends coinex$1["default"] {
         //     }
         //
         const data = this.safeList(response, 'data', []);
-        const result = {};
-        for (let i = 0; i < data.length; i++) {
-            const coin = data[i];
-            const asset = this.safeDict(coin, 'asset', {});
-            const chains = this.safeList(coin, 'chains', []);
-            const currencyId = this.safeString(asset, 'ccy');
-            if (currencyId === undefined) {
-                continue; // coinex returns empty structures for some reason
-            }
-            const code = this.safeCurrencyCode(currencyId);
-            const canDeposit = this.safeBool(asset, 'deposit_enabled');
-            const canWithdraw = this.safeBool(asset, 'withdraw_enabled');
-            const firstChain = this.safeDict(chains, 0, {});
-            const firstPrecisionString = this.parsePrecision(this.safeString(firstChain, 'withdrawal_precision'));
-            const networks = {};
-            for (let j = 0; j < chains.length; j++) {
-                const chain = chains[j];
-                const networkId = this.safeString(chain, 'chain');
-                const networkCode = this.networkIdToCode(networkId, code);
-                if (networkId === undefined) {
-                    continue;
-                }
-                const precisionString = this.parsePrecision(this.safeString(chain, 'withdrawal_precision'));
-                const feeString = this.safeString(chain, 'withdrawal_fee');
-                const minNetworkDepositString = this.safeString(chain, 'min_deposit_amount');
-                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': networkCode,
-                    'name': undefined,
-                    'active': canDepositChain && canWithdrawChain,
-                    'deposit': canDepositChain,
-                    'withdraw': canWithdrawChain,
-                    'fee': this.parseNumber(feeString),
-                    'precision': this.parseNumber(precisionString),
-                    'limits': {
-                        'amount': {
-                            'min': undefined,
-                            'max': undefined,
-                        },
-                        'deposit': {
-                            'min': this.parseNumber(minNetworkDepositString),
-                            'max': undefined,
-                        },
-                        'withdraw': {
-                            'min': this.parseNumber(minNetworkWithdrawString),
-                            'max': undefined,
-                        },
-                    },
-                    'info': chain,
-                };
-                networks[networkCode] = network;
+        return this.parseCurrencies(data);
+    }
+    parseCurrency(coin) {
+        const asset = this.safeDict(coin, 'asset', {});
+        const chains = this.safeList(coin, 'chains', []);
+        const currencyId = this.safeString(asset, 'ccy');
+        if (currencyId === undefined) {
+            return undefined; // coinex returns empty structures for some reason
+        }
+        const code = this.safeCurrencyCode(currencyId);
+        const canDeposit = this.safeBool(asset, 'deposit_enabled');
+        const canWithdraw = this.safeBool(asset, 'withdraw_enabled');
+        const firstChain = this.safeDict(chains, 0, {});
+        const firstPrecisionString = this.parsePrecision(this.safeString(firstChain, 'withdrawal_precision'));
+        const networks = {};
+        for (let j = 0; j < chains.length; j++) {
+            const chain = chains[j];
+            const networkId = this.safeString(chain, 'chain');
+            const networkCode = this.networkIdToCode(networkId, code);
+            if (networkId === undefined) {
+                continue;
             }
-            result[code] = this.safeCurrencyStructure({
-                'id': currencyId,
-                'code': code,
+            const precisionString = this.parsePrecision(this.safeString(chain, 'withdrawal_precision'));
+            const feeString = this.safeString(chain, 'withdrawal_fee');
+            const minNetworkDepositString = this.safeString(chain, 'min_deposit_amount');
+            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': networkCode,
                 'name': undefined,
-                'active': canDeposit && canWithdraw,
-                'deposit': canDeposit,
-                'withdraw': canWithdraw,
-                'fee': undefined,
-                'precision': this.parseNumber(firstPrecisionString),
+                'active': canDepositChain && canWithdrawChain,
+                'deposit': canDepositChain,
+                'withdraw': canWithdrawChain,
+                'fee': this.parseNumber(feeString),
+                'precision': this.parseNumber(precisionString),
                 'limits': {
                     'amount': {
                         'min': undefined,
                         'max': undefined,
                     },
                     'deposit': {
-                        'min': undefined,
+                        'min': this.parseNumber(minNetworkDepositString),
                         'max': undefined,
                     },
                     'withdraw': {
-                        'min': undefined,
+                        'min': this.parseNumber(minNetworkWithdrawString),
                         'max': undefined,
                     },
                 },
-                'networks': networks,
-                'type': 'crypto',
-                'info': coin,
-            });
-        }
-        return result;
+                'info': chain,
+            };
+            networks[networkCode] = network;
+        }
+        return 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': networks,
+            'type': 'crypto',
+            'info': coin,
+        });
     }
     /**
      * @method
@@ -3998,7 +3996,7 @@ class coinex extends coinex$1["default"] {
         if (networkCode === undefined) {
             throw new errors.ArgumentsRequired(this.id + ' fetchDepositAddress() requires a "network" parameter');
         }
-        request['chain'] = this.networkCodeToId(networkCode); // required for on-chain, not required for inter-user transfer
+        request['chain'] = this.networkCodeToId(networkCode, currency['code']); // required for on-chain, not required for inter-user transfer
         const response = await this.v2PrivateGetAssetsDepositAddress(this.extend(request, params));
         //
         //     {
@@ -4924,7 +4922,7 @@ class coinex extends coinex$1["default"] {
         let networkCode = undefined;
         [networkCode, params] = this.handleNetworkCodeAndParams(params);
         if (networkCode !== undefined) {
-            request['chain'] = this.networkCodeToId(networkCode); // required for on-chain, not required for inter-user transfer
+            request['chain'] = this.networkCodeToId(networkCode, currency['code']); // required for on-chain, not required for inter-user transfer
         }
         const response = await this.v2PrivatePostAssetsWithdraw(this.extend(request, params));
         //
@@ -5131,7 +5129,7 @@ class coinex extends coinex$1["default"] {
             'txid': txid,
             'timestamp': timestamp,
             'datetime': this.iso8601(timestamp),
-            'network': this.networkIdToCode(networkId),
+            'network': this.networkIdToCode(networkId, code),
             'address': address,
             'addressTo': address,
             'addressFrom': undefined,
@@ -5834,7 +5832,9 @@ class coinex extends coinex$1["default"] {
                 result['withdraw']['percentage'] = false;
                 const networkId = this.safeString(entry, 'chain');
                 if (networkId) {
-                    const networkCode = this.networkIdToCode(networkId, this.safeString(asset, 'ccy'));
+                    const currencyId = this.safeString(asset, 'ccy');
+                    const feeCode = this.safeCurrencyCode(currencyId, currency);
+                    const networkCode = this.networkIdToCode(networkId, feeCode);
                     result['networks'][networkCode] = {
                         'withdraw': {
                             'fee': this.safeNumber(entry, 'withdrawal_fee'),

package/dist/cjs/src/coinmate.js

@@ -8,7 +8,7 @@ var Precise = require('./base/Precise.js');
 var number = require('./base/functions/number.js');
 var sha256 = require('./static_dependencies/noble-hashes/sha256.js');
 
-//  ---------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 //  ---------------------------------------------------------------------------
 /**
  * @class coinmate

package/dist/cjs/src/coinmetro.js

@@ -7,7 +7,7 @@ var errors = require('./base/errors.js');
 var number = require('./base/functions/number.js');
 var Precise = require('./base/Precise.js');
 
-//  ---------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 //  ---------------------------------------------------------------------------
 /**
  * @class coinmetro
@@ -891,7 +891,7 @@ class coinmetro extends coinmetro$1["default"] {
         orderbook['nonce'] = this.safeInteger(book, 'seqNumber');
         return orderbook;
     }
-    parseBidsAsks(bidasks, priceKey = 0, amountKey = 1, countOrIdKey = 2) {
+    parseOrderBookBidsAsks(bidasks, priceKey = 0, amountKey = 1, countOrIdKey = 2) {
         const prices = Object.keys(bidasks);
         const result = [];
         for (let i = 0; i < prices.length; i++) {

package/dist/cjs/src/coinone.js

@@ -8,7 +8,7 @@ var Precise = require('./base/Precise.js');
 var number = require('./base/functions/number.js');
 var sha512 = require('./static_dependencies/noble-hashes/sha512.js');
 
-//  ---------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 //  ---------------------------------------------------------------------------
 /**
  * @class coinone

package/dist/cjs/src/coinsph.js

@@ -8,6 +8,7 @@ var number = require('./base/functions/number.js');
 var Precise = require('./base/Precise.js');
 var sha256 = require('./static_dependencies/noble-hashes/sha256.js');
 
+// ----------------------------------------------------------------------------
 /**
  * @class coinsph
  * @augments Exchange
@@ -628,7 +629,7 @@ class coinsph extends coinsph$1["default"] {
         for (let j = 0; j < networkList.length; j++) {
             const networkItem = networkList[j];
             const network = this.safeString(networkItem, 'network');
-            const networkCode = this.networkIdToCode(network);
+            const networkCode = this.networkIdToCode(network, code);
             networks[networkCode] = {
                 'info': networkItem,
                 'id': network,

package/dist/cjs/src/coinspot.js

@@ -8,7 +8,7 @@ var number = require('./base/functions/number.js');
 var sha512 = require('./static_dependencies/noble-hashes/sha512.js');
 var Precise = require('./base/Precise.js');
 
-//  ---------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 //  ---------------------------------------------------------------------------
 /**
  * @class coinspot

package/dist/cjs/src/cryptocom.js

@@ -8,7 +8,7 @@ var errors = require('./base/errors.js');
 var number = require('./base/functions/number.js');
 var sha256 = require('./static_dependencies/noble-hashes/sha256.js');
 
-//  ---------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 /**
  * @class cryptocom
  * @augments Exchange
@@ -564,7 +564,8 @@ class cryptocom extends cryptocom$1["default"] {
             response = await this.v1PrivatePostPrivateGetCurrencyNetworks(params);
         }
         catch (e) {
-            if (e instanceof errors.ExchangeError) {
+            const erString = this.exceptionMessage(e);
+            if (erString.indexOf('SYS_ERROR') >= 0) {
                 // sub-accounts can't access this endpoint
                 // {"code":"10001","msg":"SYS_ERROR"}
                 return {};
@@ -617,57 +618,54 @@ class cryptocom extends cryptocom$1["default"] {
         //
         const resultData = this.safeDict(response, 'result', {});
         const currencyMap = this.safeDict(resultData, 'currency_map', {});
-        const keys = Object.keys(currencyMap);
-        const result = {};
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            const currency = currencyMap[key];
-            const id = key;
-            const code = this.safeCurrencyCode(id);
-            const networks = {};
-            const chains = this.safeList(currency, 'network_list', []);
-            for (let j = 0; j < chains.length; j++) {
-                const chain = chains[j];
-                const networkId = this.safeString(chain, 'network_id');
-                const network = this.networkIdToCode(networkId);
-                networks[network] = {
-                    'info': chain,
-                    'id': networkId,
-                    'network': network,
-                    'active': undefined,
-                    'deposit': this.safeBool(chain, 'deposit_enabled', false),
-                    'withdraw': this.safeBool(chain, 'withdraw_enabled', false),
-                    'fee': this.safeNumber(chain, 'withdrawal_fee'),
-                    'precision': undefined,
-                    'limits': {
-                        'withdraw': {
-                            'min': this.safeNumber(chain, 'min_withdrawal_amount'),
-                            'max': undefined,
-                        },
-                    },
-                };
-            }
-            result[code] = this.safeCurrencyStructure({
-                'info': currency,
-                'id': id,
-                'code': code,
-                'name': this.safeString(currency, 'full_name'),
+        const enhancedArray = this.addKeyInArrayItems(currencyMap, '_coin_id');
+        return this.parseCurrencies(enhancedArray);
+    }
+    parseCurrency(currency) {
+        const id = this.safeString(currency, '_coin_id');
+        const code = this.safeCurrencyCode(id);
+        const networks = {};
+        const chains = this.safeList(currency, 'network_list', []);
+        for (let j = 0; j < chains.length; j++) {
+            const chain = chains[j];
+            const networkId = this.safeString(chain, 'network_id');
+            const network = this.networkIdToCode(networkId, code);
+            networks[network] = {
+                'info': chain,
+                'id': networkId,
+                'network': network,
                 'active': undefined,
-                'deposit': undefined,
-                'withdraw': undefined,
-                'fee': undefined,
+                'deposit': this.safeBool(chain, 'deposit_enabled', false),
+                'withdraw': this.safeBool(chain, 'withdraw_enabled', false),
+                'fee': this.safeNumber(chain, 'withdrawal_fee'),
                 'precision': undefined,
                 'limits': {
-                    'amount': {
-                        'min': undefined,
+                    'withdraw': {
+                        'min': this.safeNumber(chain, 'min_withdrawal_amount'),
                         'max': undefined,
                     },
                 },
-                'type': 'crypto',
-                'networks': networks,
-            });
+            };
         }
-        return result;
+        return this.safeCurrencyStructure({
+            'info': currency,
+            'id': id,
+            'code': code,
+            'name': this.safeString(currency, 'full_name'),
+            'active': undefined,
+            'deposit': undefined,
+            'withdraw': undefined,
+            'fee': undefined,
+            'precision': undefined,
+            'limits': {
+                'amount': {
+                    'min': undefined,
+                    'max': undefined,
+                },
+            },
+            'type': 'crypto',
+            'networks': networks,
+        });
     }
     /**
      * @method
@@ -2021,7 +2019,7 @@ class cryptocom extends cryptocom$1["default"] {
         }
         let networkCode = undefined;
         [networkCode, params] = this.handleNetworkCodeAndParams(params);
-        const networkId = this.networkCodeToId(networkCode);
+        const networkId = this.networkCodeToId(networkCode, code);
         if (networkId !== undefined) {
             request['network_id'] = networkId;
         }
@@ -3334,8 +3332,8 @@ class cryptocom extends cryptocom$1["default"] {
             paramsKeys = object;
         }
         else {
-            const sorted = this.keysort(object);
-            paramsKeys = Object.keys(sorted);
+            const objectKeys = Object.keys(object);
+            paramsKeys = this.sort(objectKeys);
         }
         for (let i = 0; i < paramsKeys.length; i++) {
             const key = paramsKeys[i];

package/dist/cjs/src/cryptomus.js

@@ -8,7 +8,7 @@ var Precise = require('./base/Precise.js');
 var number = require('./base/functions/number.js');
 var md5 = require('./static_dependencies/noble-hashes/md5.js');
 
-// ---------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 /**
  * @class cryptomus
@@ -79,7 +79,7 @@ class cryptomus extends cryptomus$1["default"] {
                 'fetchConvertTradeHistory': false,
                 'fetchCrossBorrowRate': false,
                 'fetchCrossBorrowRates': false,
-                'fetchCurrencies': false,
+                'fetchCurrencies': true,
                 'fetchDepositAddress': false,
                 'fetchDeposits': false,
                 'fetchDepositsWithdrawals': false,
@@ -406,46 +406,50 @@ class cryptomus extends cryptomus$1["default"] {
         //
         const coins = this.safeList(response, 'result');
         const groupedById = this.groupBy(coins, 'currency_code');
-        const keys = Object.keys(groupedById);
-        const result = {};
-        for (let i = 0; i < keys.length; i++) {
-            const id = keys[i];
-            const code = this.safeCurrencyCode(id);
-            const networks = {};
-            const networkEntries = groupedById[id];
-            for (let j = 0; j < networkEntries.length; j++) {
-                const networkEntry = networkEntries[j];
-                const networkId = this.safeString(networkEntry, 'network_code');
-                const networkCode = this.networkIdToCode(networkId);
-                networks[networkCode] = {
-                    'id': networkId,
-                    'network': networkCode,
-                    'limits': {
-                        'withdraw': {
-                            'min': this.safeNumber(networkEntry, 'min_withdraw'),
-                            'max': this.safeNumber(networkEntry, 'max_withdraw'),
-                        },
-                        'deposit': {
-                            'min': this.safeNumber(networkEntry, 'min_deposit'),
-                            'max': this.safeNumber(networkEntry, 'max_deposit'),
-                        },
-                    },
-                    'active': undefined,
-                    'deposit': this.safeBool(networkEntry, 'can_withdraw'),
-                    'withdraw': this.safeBool(networkEntry, 'can_deposit'),
-                    'fee': undefined,
-                    'precision': undefined,
-                    'info': networkEntry,
-                };
+        const groupedArray = Object.values(groupedById);
+        return this.parseCurrencies(groupedArray);
+    }
+    parseCurrency(rawCurrency) {
+        // currency here is array of networks
+        let id = undefined; // all entried have same id, as they were grouped by
+        let code = undefined;
+        const networks = {};
+        for (let i = 0; i < rawCurrency.length; i++) {
+            const networkEntry = rawCurrency[i];
+            // set ID on first loop
+            if (id === undefined) {
+                id = this.safeString(networkEntry, 'currency_code');
+                code = this.safeCurrencyCode(id);
             }
-            result[code] = this.safeCurrencyStructure({
-                'id': id,
-                'code': code,
-                'networks': networks,
-                'info': networkEntries,
-            });
+            const networkId = this.safeString(networkEntry, 'network_code');
+            const networkCode = this.networkIdToCode(networkId, code);
+            networks[networkCode] = {
+                'id': networkId,
+                'network': networkCode,
+                'limits': {
+                    'withdraw': {
+                        'min': this.safeNumber(networkEntry, 'min_withdraw'),
+                        'max': this.safeNumber(networkEntry, 'max_withdraw'),
+                    },
+                    'deposit': {
+                        'min': this.safeNumber(networkEntry, 'min_deposit'),
+                        'max': this.safeNumber(networkEntry, 'max_deposit'),
+                    },
+                },
+                'active': undefined,
+                'deposit': this.safeBool(networkEntry, 'can_deposit'),
+                'withdraw': this.safeBool(networkEntry, 'can_withdraw'),
+                'fee': undefined,
+                'precision': undefined,
+                'info': networkEntry,
+            };
         }
-        return result;
+        return this.safeCurrencyStructure({
+            'id': id,
+            'code': code,
+            'networks': networks,
+            'info': rawCurrency,
+        });
     }
     /**
      * @method

package/dist/cjs/src/deepcoin.js

@@ -8,7 +8,7 @@ var sha256 = require('./static_dependencies/noble-hashes/sha256.js');
 var Precise = require('./base/Precise.js');
 var errors = require('./base/errors.js');
 
-// ---------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 /**
  * @class deepcoin
@@ -816,7 +816,7 @@ class deepcoin extends deepcoin$1["default"] {
             'instId': market['id'],
         };
         if (limit !== undefined) {
-            request['limit'] = Math.min(limit, 2000);
+            request['limit'] = Math.min(limit, 500);
         }
         const productGroup = this.getProductGroupFromMarket(market);
         request['productGroup'] = productGroup;
@@ -1066,7 +1066,7 @@ class deepcoin extends deepcoin$1["default"] {
         const amount = this.safeNumber(transaction, 'amount');
         const timestamp = this.safeTimestamp(transaction, 'createTime');
         const networkId = this.safeString(transaction, 'chainName');
-        const network = this.networkIdToCode(networkId);
+        const network = this.networkIdToCode(networkId, code);
         const status = this.parseTransactionStatus(this.safeString(transaction, 'status'));
         return {
             'info': transaction,
@@ -1213,10 +1213,11 @@ class deepcoin extends deepcoin$1["default"] {
         const chain = this.safeString(response, 'chain');
         const address = this.safeString(response, 'address');
         this.checkAddress(address);
+        const code = this.safeString(currency, 'code');
         return {
             'info': response,
             'currency': undefined,
-            'network': this.networkIdToCode(chain),
+            'network': this.networkIdToCode(chain, code),
             'address': address,
             'tag': this.safeString(response, 'memo'),
         };