ccxt 4.5.56 → 4.5.57

package/js/src/coinex.js

@@ -725,90 +725,88 @@ export default class coinex extends Exchange {
         //     }
         //
         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
@@ -3993,7 +3991,7 @@ export default class coinex extends Exchange {
         if (networkCode === undefined) {
             throw new 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));
         //
         //     {
@@ -4919,7 +4917,7 @@ export default class coinex extends Exchange {
         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));
         //
@@ -5126,7 +5124,7 @@ export default class coinex extends Exchange {
             'txid': txid,
             'timestamp': timestamp,
             'datetime': this.iso8601(timestamp),
-            'network': this.networkIdToCode(networkId),
+            'network': this.networkIdToCode(networkId, code),
             'address': address,
             'addressTo': address,
             'addressFrom': undefined,
@@ -5829,7 +5827,9 @@ export default class coinex extends Exchange {
                 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/js/src/coinmetro.d.ts

@@ -79,7 +79,7 @@ export default class coinmetro extends Exchange {
      * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/?id=order-book-structure} indexed by market symbols
      */
     fetchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
-    parseBidsAsks(bidasks: any, priceKey?: IndexType, amountKey?: IndexType, countOrIdKey?: IndexType): any[];
+    parseOrderBookBidsAsks(bidasks: any, priceKey?: IndexType, amountKey?: IndexType, countOrIdKey?: IndexType): any[];
     /**
      * @method
      * @name coinmetro#fetchTickers

package/js/src/coinmetro.js

@@ -886,7 +886,7 @@ export default class coinmetro extends Exchange {
         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/js/src/coinsph.js

@@ -623,7 +623,7 @@ export default class coinsph extends Exchange {
         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/js/src/cryptocom.d.ts

@@ -15,6 +15,7 @@ export default class cryptocom extends Exchange {
      * @returns {object} an associative dictionary of currencies
      */
     fetchCurrencies(params?: {}): Promise<Currencies>;
+    parseCurrency(currency: Dict): Currency;
     /**
      * @method
      * @name cryptocom#fetchMarkets

package/js/src/cryptocom.js

@@ -559,7 +559,8 @@ export default class cryptocom extends Exchange {
             response = await this.v1PrivatePostPrivateGetCurrencyNetworks(params);
         }
         catch (e) {
-            if (e instanceof ExchangeError) {
+            const erString = this.exceptionMessage(e);
+            if (erString.indexOf('"msg":"SYS_ERROR"') >= 0) {
                 // sub-accounts can't access this endpoint
                 // {"code":"10001","msg":"SYS_ERROR"}
                 return {};
@@ -612,57 +613,54 @@ export default class cryptocom extends Exchange {
         //
         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
@@ -2016,7 +2014,7 @@ export default class cryptocom extends Exchange {
         }
         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;
         }
@@ -3329,8 +3327,8 @@ export default class cryptocom extends Exchange {
             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/js/src/cryptomus.d.ts

@@ -1,5 +1,5 @@
 import Exchange from './abstract/cryptomus.js';
-import type { Balances, Currencies, Dict, int, Int, Market, Num, Order, OrderBook, OrderType, OrderSide, Str, Strings, Ticker, Tickers, Trade, TradingFees } from './base/types.js';
+import type { Balances, Currencies, Dict, int, Int, Market, Num, Order, OrderBook, OrderType, OrderSide, Str, Strings, Ticker, Tickers, Trade, TradingFees, Currency } from './base/types.js';
 /**
  * @class cryptomus
  * @augments Exchange
@@ -25,6 +25,7 @@ export default class cryptomus extends Exchange {
      * @returns {object} an associative dictionary of currencies
      */
     fetchCurrencies(params?: {}): Promise<Currencies>;
+    parseCurrency(rawCurrency: Dict): Currency;
     /**
      * @method
      * @name cryptomus#fetchTickers

package/js/src/cryptomus.js

@@ -74,7 +74,7 @@ export default class cryptomus extends Exchange {
                 'fetchConvertTradeHistory': false,
                 'fetchCrossBorrowRate': false,
                 'fetchCrossBorrowRates': false,
-                'fetchCurrencies': false,
+                'fetchCurrencies': true,
                 'fetchDepositAddress': false,
                 'fetchDeposits': false,
                 'fetchDepositsWithdrawals': false,
@@ -401,46 +401,50 @@ export default class cryptomus extends Exchange {
         //
         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/js/src/deepcoin.js

@@ -1061,7 +1061,7 @@ export default class deepcoin extends Exchange {
         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,
@@ -1208,10 +1208,11 @@ export default class deepcoin extends Exchange {
         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'),
         };

package/js/src/delta.d.ts

@@ -39,6 +39,7 @@ export default class delta extends Exchange {
      * @returns {object} an associative dictionary of currencies
      */
     fetchCurrencies(params?: {}): Promise<Currencies>;
+    parseCurrency(rawCurrency: Dict): Currency;
     loadMarkets(reload?: boolean, params?: {}): Promise<import("./base/types.js").Dictionary<MarketInterface>>;
     indexByStringifiedNumericId(input: any): Dict;
     /**

package/js/src/delta.js

@@ -560,62 +560,60 @@ export default class delta extends Exchange {
         //     }
         //
         const currencies = this.safeList(response, 'result', []);
-        const result = {};
-        for (let i = 0; i < currencies.length; i++) {
-            const currency = currencies[i];
-            const id = this.safeString(currency, 'symbol');
-            const numericId = this.safeInteger(currency, 'id');
-            const code = this.safeCurrencyCode(id);
-            const chains = this.safeList(currency, 'networks', []);
-            const networks = {};
-            for (let j = 0; j < chains.length; j++) {
-                const chain = chains[j];
-                const networkId = this.safeString(chain, 'network');
-                const networkCode = this.networkIdToCode(networkId);
-                networks[networkCode] = {
-                    'id': networkId,
-                    'network': networkCode,
-                    'name': this.safeString(chain, 'name'),
-                    'info': chain,
-                    'active': this.safeString(chain, 'status') === 'enabled',
-                    'deposit': this.safeString(chain, 'deposit_status') === 'enabled',
-                    'withdraw': this.safeString(chain, 'withdrawal_status') === 'enabled',
-                    'fee': this.safeNumber(chain, 'base_withdrawal_fee'),
-                    'limits': {
-                        'deposit': {
-                            'min': this.safeNumber(chain, 'min_deposit_amount'),
-                            'max': undefined,
-                        },
-                        'withdraw': {
-                            'min': this.safeNumber(chain, 'min_withdrawal_amount'),
-                            'max': undefined,
-                        },
-                    },
-                };
-            }
-            result[code] = this.safeCurrencyStructure({
-                'id': id,
-                'numericId': numericId,
-                'code': code,
-                'name': this.safeString(currency, 'name'),
-                'info': currency,
-                'active': undefined,
-                'deposit': this.safeString(currency, 'deposit_status') === 'enabled',
-                'withdraw': this.safeString(currency, 'withdrawal_status') === 'enabled',
-                'fee': this.safeNumber(currency, 'base_withdrawal_fee'),
-                'precision': this.parseNumber(this.parsePrecision(this.safeString(currency, 'precision'))),
+        return this.parseCurrencies(currencies);
+    }
+    parseCurrency(rawCurrency) {
+        const id = this.safeString(rawCurrency, 'symbol');
+        const numericId = this.safeInteger(rawCurrency, 'id');
+        const code = this.safeCurrencyCode(id);
+        const chains = this.safeList(rawCurrency, 'networks', []);
+        const networks = {};
+        for (let j = 0; j < chains.length; j++) {
+            const chain = chains[j];
+            const networkId = this.safeString(chain, 'network');
+            const networkCode = this.networkIdToCode(networkId, code);
+            networks[networkCode] = {
+                'id': networkId,
+                'network': networkCode,
+                'name': this.safeString(chain, 'name'),
+                'info': chain,
+                'active': this.safeString(chain, 'status') === 'enabled',
+                'deposit': this.safeString(chain, 'deposit_status') === 'enabled',
+                'withdraw': this.safeString(chain, 'withdrawal_status') === 'enabled',
+                'fee': this.safeNumber(chain, 'base_withdrawal_fee'),
                 'limits': {
-                    'amount': { 'min': undefined, 'max': undefined },
+                    'deposit': {
+                        'min': this.safeNumber(chain, 'min_deposit_amount'),
+                        'max': undefined,
+                    },
                     'withdraw': {
-                        'min': this.safeNumber(currency, 'min_withdrawal_amount'),
+                        'min': this.safeNumber(chain, 'min_withdrawal_amount'),
                         'max': undefined,
                     },
                 },
-                'networks': networks,
-                'type': 'crypto',
-            });
+            };
         }
-        return result;
+        return this.safeCurrencyStructure({
+            'id': id,
+            'numericId': numericId,
+            'code': code,
+            'name': this.safeString(rawCurrency, 'name'),
+            'info': rawCurrency,
+            'active': undefined,
+            'deposit': this.safeString(rawCurrency, 'deposit_status') === 'enabled',
+            'withdraw': this.safeString(rawCurrency, 'withdrawal_status') === 'enabled',
+            'fee': this.safeNumber(rawCurrency, 'base_withdrawal_fee'),
+            'precision': this.parseNumber(this.parsePrecision(this.safeString(rawCurrency, 'precision'))),
+            'limits': {
+                'amount': { 'min': undefined, 'max': undefined },
+                'withdraw': {
+                    'min': this.safeNumber(rawCurrency, 'min_withdrawal_amount'),
+                    'max': undefined,
+                },
+            },
+            'networks': networks,
+            'type': 'crypto',
+        });
     }
     async loadMarkets(reload = false, params = {}) {
         const markets = await super.loadMarkets(reload, params);
@@ -2603,11 +2601,12 @@ export default class delta extends Exchange {
         const address = this.safeString(depositAddress, 'address');
         const marketId = this.safeString(depositAddress, 'asset_symbol');
         const networkId = this.safeString(depositAddress, 'network');
+        const code = this.safeCurrencyCode(marketId, currency);
         this.checkAddress(address);
         return {
             'info': depositAddress,
-            'currency': this.safeCurrencyCode(marketId, currency),
-            'network': this.networkIdToCode(networkId),
+            'currency': code,
+            'network': this.networkIdToCode(networkId, code),
             'address': address,
             'tag': this.safeString(depositAddress, 'memo'),
         };