ccxt 4.5.55 → 4.5.57

package/dist/cjs/src/pro/gate.js

@@ -636,7 +636,7 @@ class gate extends gate$1["default"] {
         for (let i = 0; i < bidAsks.length; i++) {
             const bidAsk = bidAsks[i];
             if (Array.isArray(bidAsk)) {
-                bookSide.storeArray(this.parseBidAsk(bidAsk));
+                bookSide.storeArray(this.parseOrderBookBidAsk(bidAsk));
             }
             else {
                 const price = this.safeFloat(bidAsk, 'p');

package/dist/cjs/src/pro/grvt.js

@@ -578,6 +578,14 @@ class grvt extends grvt$1["default"] {
             orderbook['timestamp'] = timestamp;
             orderbook['datetime'] = this.iso8601(timestamp);
         }
+        // grvt defaults to the delta channel (v1.book.d); if the very first
+        // message is a delta, the freshly-created orderbook has symbol=null
+        // because no snapshot has reset it yet. Set it unconditionally — we
+        // know the symbol from the selector regardless of channel. Java's
+        // typed WsOrderBook surfaces this as `"symbol":null` in the output;
+        // Python/JS dict-backed orderbooks happen to mask it but the
+        // unconditional assignment is correct for every language.
+        orderbook['symbol'] = symbol;
         orderbook['nonce'] = sequenceNumber;
         const messageHash = 'orderbook::' + symbol;
         this.orderbooks[symbol] = orderbook;

package/dist/cjs/src/pro/htx.js

@@ -1361,10 +1361,10 @@ class htx extends htx$1["default"] {
      * @see https://www.huobi.com/en-in/opend/newApiPages/?id=28c34a7d-77ae-11ed-9966-0242ac110003
      * @see https://www.huobi.com/en-in/opend/newApiPages/?id=5d5156b5-77b6-11ed-9966-0242ac110003
      * @description watch all open positions. Note: huobi has one channel for each marginMode and type
-     * @param {string[]|undefined} symbols list of unified market symbols
-     * @param since
-     * @param limit
-     * @param {object} params extra parameters specific to the exchange API endpoint
+     * @param {string[]} [symbols] list of unified market symbols
+     * @param {int} [since] timestamp in ms of the earliest position to fetch
+     * @param {int} [limit] the maximum number of positions to fetch
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {object[]} a list of [position structure]{@link https://docs.ccxt.com/en/latest/manual.html#position-structure}
      */
     async watchPositions(symbols = undefined, since = undefined, limit = undefined, params = {}) {

package/dist/cjs/src/pro/independentreserve.js

@@ -241,7 +241,7 @@ class independentreserve extends independentreserve$1["default"] {
         return result;
     }
     handleDelta(bookside, delta) {
-        const bidAsk = this.parseBidAsk(delta, 'Price', 'Volume');
+        const bidAsk = this.parseOrderBookBidAsk(delta, 'Price', 'Volume');
         bookside.storeArray(bidAsk);
     }
     handleDeltas(bookside, deltas) {

package/dist/cjs/src/pro/krakenfutures.js

@@ -266,10 +266,10 @@ class krakenfutures extends krakenfutures$1["default"] {
      * @name krakenfutures#watchPositions
      * @see https://docs.futures.kraken.com/#websocket-api-private-feeds-open-positions
      * @description watch all open positions
-     * @param {string[]|undefined} symbols list of unified market symbols
-     * @param since
-     * @param limit
-     * @param {object} params extra parameters specific to the exchange API endpoint
+     * @param {string[]} [symbols] list of unified market symbols
+     * @param {int} [since] timestamp in ms of the earliest position to fetch
+     * @param {int} [limit] the maximum number of positions to fetch
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {object[]} a list of [position structure]{@link https://docs.ccxt.com/en/latest/manual.html#position-structure}
      */
     async watchPositions(symbols = undefined, since = undefined, limit = undefined, params = {}) {
@@ -1542,8 +1542,20 @@ class krakenfutures extends krakenfutures$1["default"] {
         //        event: 'alert',
         //        message: 'Failed to subscribe to authenticated feed'
         //    }
+        //    {
+        //        event: 'alert',
+        //        message: 'Already subscribed to feed, re-requesting'
+        //    }
         //
         const errMsg = this.safeString(message, 'message');
+        // Benign "already subscribed" notice: the original subscription is still
+        // active and delivering data on this socket. The generic client.reject
+        // below rejects every pending future on the connection, so a stray
+        // re-subscribe warning would kill unrelated in-flight watch* calls —
+        // mirrors the bitmart 90008 fix.
+        if (errMsg !== undefined && errMsg.indexOf('Already subscribed') >= 0) {
+            return false;
+        }
         try {
             throw new errors.ExchangeError(this.id + ' ' + errMsg);
         }

package/dist/cjs/src/pro/kucoin.js

@@ -1753,7 +1753,7 @@ class kucoin extends kucoin$1["default"] {
     }
     handleBidAsks(bookSide, bidAsks) {
         for (let i = 0; i < bidAsks.length; i++) {
-            const bidAsk = this.parseBidAsk(bidAsks[i]);
+            const bidAsk = this.parseOrderBookBidAsk(bidAsks[i]);
             bookSide.storeArray(bidAsk);
         }
     }

package/dist/cjs/src/pro/luno.js

@@ -214,8 +214,8 @@ class luno extends luno$1["default"] {
         client.resolve(orderbook, messageHash);
     }
     customParseOrderBook(orderbook, symbol, timestamp = undefined, bidsKey = 'bids', asksKey = 'asks', priceKey = 'price', amountKey = 'volume', countOrIdKey = 2) {
-        const bids = this.parseBidsAsks(this.safeValue(orderbook, bidsKey, []), priceKey, amountKey, countOrIdKey);
-        const asks = this.parseBidsAsks(this.safeValue(orderbook, asksKey, []), priceKey, amountKey, countOrIdKey);
+        const bids = this.parseOrderBookBidsAsks(this.safeValue(orderbook, bidsKey, []), priceKey, amountKey, countOrIdKey);
+        const asks = this.parseOrderBookBidsAsks(this.safeValue(orderbook, asksKey, []), priceKey, amountKey, countOrIdKey);
         return {
             'symbol': symbol,
             'bids': this.sortBy(bids, 0, true),
@@ -225,7 +225,7 @@ class luno extends luno$1["default"] {
             'nonce': undefined,
         };
     }
-    parseBidsAsks(bidasks, priceKey = 'price', amountKey = 'volume', thirdKey = 2) {
+    parseOrderBookBidsAsks(bidasks, priceKey = 'price', amountKey = 'volume', thirdKey = 2) {
         bidasks = this.toArray(bidasks);
         const result = [];
         for (let i = 0; i < bidasks.length; i++) {

package/dist/cjs/src/pro/modetrade.js

@@ -961,9 +961,9 @@ class modetrade extends modetrade$1["default"] {
      * @see https://orderly.network/docs/build-on-evm/evm-api/websocket-api/private/position-push
      * @description watch all open positions
      * @param {string[]} [symbols] list of unified market symbols
-     * @param since timestamp in ms of the earliest position to fetch
-     * @param limit the maximum number of positions to fetch
-     * @param {object} params extra parameters specific to the exchange API endpoint
+     * @param {int} [since] timestamp in ms of the earliest position to fetch
+     * @param {int} [limit] the maximum number of positions to fetch
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {object[]} a list of [position structure]{@link https://docs.ccxt.com/en/latest/manual.html#position-structure}
      */
     async watchPositions(symbols = undefined, since = undefined, limit = undefined, params = {}) {

package/dist/cjs/src/pro/okx.js

@@ -1702,10 +1702,10 @@ class okx extends okx$1["default"] {
      * @name okx#watchPositions
      * @see https://www.okx.com/docs-v5/en/#trading-account-websocket-positions-channel
      * @description watch all open positions
-     * @param {string[]|undefined} symbols list of unified market symbols
-     * @param since
-     * @param limit
-     * @param {object} params extra parameters specific to the exchange API endpoint
+     * @param {string[]} [symbols] list of unified market symbols
+     * @param {int} [since] timestamp in ms of the earliest position to fetch
+     * @param {int} [limit] the maximum number of positions to fetch
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {object[]} a list of [position structure]{@link https://docs.ccxt.com/en/latest/manual.html#position-structure}
      */
     async watchPositions(symbols = undefined, since = undefined, limit = undefined, params = {}) {

package/dist/cjs/src/pro/onetrading.js

@@ -391,7 +391,7 @@ class onetrading extends onetrading$1["default"] {
         //
         //   [ 'BUY', "0.053595", "0" ]
         //
-        const bidAsk = this.parseBidAsk(delta, 1, 2);
+        const bidAsk = this.parseOrderBookBidAsk(delta, 1, 2);
         const type = this.safeString(delta, 0);
         if (type === 'BUY') {
             const bids = orderbook['bids'];

package/dist/cjs/src/pro/toobit.js

@@ -577,7 +577,7 @@ class toobit extends toobit$1["default"] {
         }
     }
     handleDelta(bookside, delta) {
-        const bidAsk = this.parseBidAsk(delta);
+        const bidAsk = this.parseOrderBookBidAsk(delta);
         bookside.storeArray(bidAsk);
     }
     handleOrderBookPartialSnapshot(client, message) {

package/dist/cjs/src/pro/weex.js

@@ -882,7 +882,7 @@ class weex extends weex$1["default"] {
         client.resolve(orderbook, messageHash);
     }
     handleDelta(bookside, delta) {
-        const bidAsk = this.parseBidAsk(delta);
+        const bidAsk = this.parseOrderBookBidAsk(delta);
         bookside.storeArray(bidAsk);
     }
     /**

package/dist/cjs/src/pro/woo.js

@@ -1202,10 +1202,10 @@ class woo extends woo$1["default"] {
      * @name woo#watchPositions
      * @see https://docs.woox.io/#position-push
      * @description watch all open positions
-     * @param {string[]|undefined} symbols list of unified market symbols
-     * @param since
-     * @param limit
-     * @param {object} params extra parameters specific to the exchange API endpoint
+     * @param {string[]} [symbols] list of unified market symbols
+     * @param {int} [since] timestamp in ms of the earliest position to fetch
+     * @param {int} [limit] the maximum number of positions to fetch
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {object[]} a list of [position structure]{@link https://docs.ccxt.com/en/latest/manual.html#position-structure}
      */
     async watchPositions(symbols = undefined, since = undefined, limit = undefined, params = {}) {

package/dist/cjs/src/pro/woofipro.js

@@ -961,9 +961,9 @@ class woofipro extends woofipro$1["default"] {
      * @see https://orderly.network/docs/build-on-omnichain/evm-api/websocket-api/private/position-push
      * @description watch all open positions
      * @param {string[]} [symbols] list of unified market symbols
-     * @param since timestamp in ms of the earliest position to fetch
-     * @param limit the maximum number of positions to fetch
-     * @param {object} params extra parameters specific to the exchange API endpoint
+     * @param {int} [since] timestamp in ms of the earliest position to fetch
+     * @param {int} [limit] the maximum number of positions to fetch
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @returns {object[]} a list of [position structure]{@link https://docs.ccxt.com/en/latest/manual.html#position-structure}
      */
     async watchPositions(symbols = undefined, since = undefined, limit = undefined, params = {}) {

package/dist/cjs/src/pro/xt.js

@@ -603,7 +603,7 @@ class xt extends xt$1["default"] {
         }
     }
     async loadPositionsSnapshot(client, messageHash) {
-        const positions = await this.fetchPositions(undefined);
+        const positions = await this.fetchPositions();
         this.positions = new Cache.ArrayCacheBySymbolBySide();
         const cache = this.positions;
         for (let i = 0; i < positions.length; i++) {

package/dist/cjs/src/static_dependencies/starknet/utils/hash/classHash.js

@@ -2,9 +2,9 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var index$1 = require('../../../scure-starknet/index.js');
+var index = require('../../../scure-starknet/index.js');
 var constants = require('../../constants.js');
-var index = require('../calldata/index.js');
+var index$1 = require('../calldata/index.js');
 var cairo = require('../calldata/cairo.js');
 require('../../../scure-base/index.js');
 var num = require('../num.js');
@@ -13,10 +13,10 @@ var num = require('../num.js');
  * Class Hash
  */
 function computePedersenHash(a, b) {
-    return index$1.pedersen(BigInt(a), BigInt(b));
+    return index.pedersen(BigInt(a), BigInt(b));
 }
 function computePoseidonHash(a, b) {
-    return num.toHex(index$1.poseidonHash(BigInt(a), BigInt(b)));
+    return num.toHex(index.poseidonHash(BigInt(a), BigInt(b)));
 }
 /**
  * Compute pedersen hash from data
@@ -24,19 +24,19 @@ function computePoseidonHash(a, b) {
  */
 function computeHashOnElements(data) {
     return [...data, data.length]
-        .reduce((x, y) => index$1.pedersen(BigInt(x), BigInt(y)), 0)
+        .reduce((x, y) => index.pedersen(BigInt(x), BigInt(y)), 0)
         .toString();
 }
 const computePedersenHashOnElements = computeHashOnElements;
 function computePoseidonHashOnElements(data) {
-    return num.toHex(index$1.poseidonHashMany(data.map((x) => BigInt(x))));
+    return num.toHex(index.poseidonHashMany(data.map((x) => BigInt(x))));
 }
 /**
  * Calculate contract address from class hash
  * @returns format: hex-string
  */
 function calculateContractAddressFromHash(salt, classHash, constructorCalldata, deployerAddress) {
-    const compiledCalldata = index.CallData.compile(constructorCalldata);
+    const compiledCalldata = index$1.CallData.compile(constructorCalldata);
     const constructorCalldataHash = computeHashOnElements(compiledCalldata);
     const CONTRACT_ADDRESS_PREFIX = cairo.felt('0x535441524b4e45545f434f4e54524143545f41444452455353'); // Equivalent to 'STARKNET_CONTRACT_ADDRESS'
     const hash = computeHashOnElements([

package/dist/cjs/src/tokocrypto.js

@@ -2477,7 +2477,7 @@ class tokocrypto extends tokocrypto$1["default"] {
             request['addressTag'] = tag;
         }
         const [networkCode, query] = this.handleNetworkCodeAndParams(params);
-        const networkId = this.networkCodeToId(networkCode);
+        const networkId = this.networkCodeToId(networkCode, code);
         if (networkId !== undefined) {
             request['network'] = networkId.toUpperCase();
         }

package/dist/cjs/src/toobit.js

@@ -612,7 +612,7 @@ class toobit extends toobit$1["default"] {
         for (let j = 0; j < rawNetworks.length; j++) {
             const rawNetwork = rawNetworks[j];
             const networkId = this.safeString(rawNetwork, 'chainType');
-            const networkCode = this.networkIdToCode(networkId);
+            const networkCode = this.networkIdToCode(networkId, code);
             networks[networkCode] = {
                 'id': networkId,
                 'network': networkCode,
@@ -2518,7 +2518,7 @@ class toobit extends toobit$1["default"] {
     async fetchWithdrawals(code = undefined, since = undefined, limit = undefined, params = {}) {
         return await this.fetchDepositsOrWithdrawalsHelper('withdrawals', code, since, limit, params);
     }
-    async fetchDepositsOrWithdrawalsHelper(type, code, since, limit, params) {
+    async fetchDepositsOrWithdrawalsHelper(type, code, since, limit, params = {}) {
         await this.loadMarkets();
         let currency = undefined;
         let request = {};
@@ -2700,7 +2700,7 @@ class toobit extends toobit$1["default"] {
         if (networkCode === undefined) {
             throw new errors.ArgumentsRequired(this.id + ' fetchDepositAddress() : param["network"] is required');
         }
-        request['chainType'] = this.networkCodeToId(networkCode);
+        request['chainType'] = this.networkCodeToId(networkCode, code);
         const response = await this.privateGetApiV1AccountDepositAddress(this.extend(request, paramsOmitted));
         //
         //     {

package/dist/cjs/src/upbit.js

@@ -680,8 +680,8 @@ class upbit extends upbit$1["default"] {
             const timestamp = this.safeInteger(orderbook, 'timestamp');
             result[symbol] = {
                 'symbol': symbol,
-                'bids': this.sortBy(this.parseBidsAsks(orderbook['orderbook_units'], 'bid_price', 'bid_size'), 0, true),
-                'asks': this.sortBy(this.parseBidsAsks(orderbook['orderbook_units'], 'ask_price', 'ask_size'), 0),
+                'bids': this.sortBy(this.parseOrderBookBidsAsks(orderbook['orderbook_units'], 'bid_price', 'bid_size'), 0, true),
+                'asks': this.sortBy(this.parseOrderBookBidsAsks(orderbook['orderbook_units'], 'ask_price', 'ask_size'), 0),
                 'timestamp': timestamp,
                 'datetime': this.iso8601(timestamp),
                 'nonce': undefined,
@@ -2170,7 +2170,7 @@ class upbit extends upbit$1["default"] {
         return {
             'info': depositAddress,
             'currency': code,
-            'network': this.networkIdToCode(networkId),
+            'network': this.networkIdToCode(networkId, code),
             'address': address,
             'tag': tag,
         };

package/dist/cjs/src/weex.js

@@ -496,20 +496,17 @@ class weex extends weex$1["default"] {
                     'ETH': 'ERC20',
                     'POLYGON': 'POLYGON(MATIC)',
                     'MATIC': 'POLYGON(MATIC)',
-                    'ARBITRUM': 'ARBITRUM(ARB)',
-                    'ARB': 'ARBITRUM(ARB)',
-                    'SOLANA': 'SOLANA(SOL)',
+                    'ARBONE': 'ARBITRUM(ARB)',
                     'SOL': 'SOLANA(SOL)',
                     'OP': 'OPTIMISM(OP)',
                     'OPTIMISM': 'OPTIMISM(OP)',
-                    'AVALANCHEC': 'AVALANCHE_C(AVAX_C)',
                     'AVAXC': 'AVALANCHE_C(AVAX_C)',
                 },
                 'networksById': {
                     'BEP20(BSC)': 'BEP20',
                     'ERC20': 'ERC20',
                     'POLYGON(MATIC)': 'MATIC',
-                    'ARBITRUM(ARB)': 'ARB',
+                    'ARBITRUM(ARB)': 'ARBONE',
                     'SOLANA(SOL)': 'SOL',
                     'OPTIMISM(OP)': 'OP',
                     'AVALANCHE_C(AVAX_C)': 'AVAXC',
@@ -853,73 +850,71 @@ class weex extends weex$1["default"] {
         //         }
         //     ]
         //
-        const result = {};
-        for (let i = 0; i < response.length; i++) {
-            const currency = this.safeDict(response, i);
-            const currencyId = this.safeString(currency, 'coin');
-            const code = this.safeCurrencyCode(currencyId);
-            const name = this.safeString(currency, 'name');
-            const networks = {};
-            const chains = this.safeList(currency, 'networkList', []);
-            for (let j = 0; j < chains.length; j++) {
-                const chain = this.safeDict(chains, j);
-                const networkId = this.safeString(chain, 'network');
-                const networkCode = this.networkIdToCode(networkId);
-                networks[networkCode] = {
-                    'info': chain,
-                    'id': networkId,
-                    'network': networkCode,
-                    'active': undefined,
-                    'deposit': this.safeBool(chain, 'depositEnable'),
-                    'withdraw': this.safeBool(chain, 'withdrawEnable'),
-                    'fee': this.safeNumber(chain, 'withdrawFee'),
-                    'precision': this.safeNumber(chain, 'withdrawIntegerMultiple'),
-                    'isDefault': this.safeBool(chain, 'isDefault', false),
-                    'limits': {
-                        'withdraw': {
-                            'min': this.safeNumber(chain, 'withdrawMin'),
-                            'max': undefined,
-                        },
-                        'deposit': {
-                            'min': this.safeNumber(chain, 'depositDust'),
-                            'max': undefined,
-                        },
-                    },
-                };
-            }
-            const networkKeys = Object.keys(networks);
-            const networksLength = networkKeys.length;
-            const emptyChains = networksLength === 0; // non-functional coins
-            const valueForEmpty = emptyChains ? false : undefined;
-            result[code] = this.safeCurrencyStructure({
-                'info': currency,
-                'code': code,
-                'id': currencyId,
-                'type': 'crypto',
-                'name': name,
+        return this.parseCurrencies(response);
+    }
+    parseCurrency(rawCurrency) {
+        const currencyId = this.safeString(rawCurrency, 'coin');
+        const code = this.safeCurrencyCode(currencyId);
+        const name = this.safeString(rawCurrency, 'name');
+        const networks = {};
+        const chains = this.safeList(rawCurrency, 'networkList', []);
+        for (let j = 0; j < chains.length; j++) {
+            const chain = this.safeDict(chains, j);
+            const networkId = this.safeString(chain, 'network');
+            const networkCode = this.networkIdToCode(networkId, code);
+            networks[networkCode] = {
+                'info': chain,
+                'id': networkId,
+                'network': networkCode,
                 'active': undefined,
-                'deposit': valueForEmpty,
-                'withdraw': valueForEmpty,
-                'fee': undefined,
-                'precision': undefined,
+                'deposit': this.safeBool(chain, 'depositEnable'),
+                'withdraw': this.safeBool(chain, 'withdrawEnable'),
+                'fee': this.safeNumber(chain, 'withdrawFee'),
+                'precision': this.safeNumber(chain, 'withdrawIntegerMultiple'),
+                'isDefault': this.safeBool(chain, 'isDefault', false),
                 'limits': {
-                    'amount': {
-                        'min': undefined,
-                        'max': undefined,
-                    },
                     'withdraw': {
-                        'min': undefined,
+                        'min': this.safeNumber(chain, 'withdrawMin'),
                         'max': undefined,
                     },
                     'deposit': {
-                        'min': undefined,
+                        'min': this.safeNumber(chain, 'depositDust'),
                         'max': undefined,
                     },
                 },
-                'networks': networks,
-            });
+            };
         }
-        return result;
+        const networkKeys = Object.keys(networks);
+        const networksLength = networkKeys.length;
+        const emptyChains = networksLength === 0; // non-functional coins
+        const valueForEmpty = emptyChains ? false : undefined;
+        return this.safeCurrencyStructure({
+            'info': rawCurrency,
+            'code': code,
+            'id': currencyId,
+            'type': 'crypto',
+            'name': name,
+            'active': undefined,
+            'deposit': valueForEmpty,
+            'withdraw': valueForEmpty,
+            'fee': undefined,
+            'precision': undefined,
+            'limits': {
+                'amount': {
+                    'min': undefined,
+                    'max': undefined,
+                },
+                'withdraw': {
+                    'min': undefined,
+                    'max': undefined,
+                },
+                'deposit': {
+                    'min': undefined,
+                    'max': undefined,
+                },
+            },
+            'networks': networks,
+        });
     }
     /**
      * @method

package/dist/cjs/src/whitebit.js

@@ -644,76 +644,74 @@ class whitebit extends whitebit$1["default"] {
         //   }
         // }
         //
-        const ids = Object.keys(response);
-        const result = {};
-        for (let i = 0; i < ids.length; i++) {
-            const id = ids[i];
-            const currency = response[id];
-            // const name = this.safeString (currency, 'name'); // breaks down in Python due to utf8 encoding issues on the exchange side
-            const code = this.safeCurrencyCode(id);
-            const hasProvider = ('providers' in currency);
-            const networks = {};
-            const rawNetworks = this.safeDict(currency, 'networks', {});
-            const depositsNetworks = this.safeList(rawNetworks, 'deposits', []);
-            const withdrawsNetworks = this.safeList(rawNetworks, 'withdraws', []);
-            const networkLimits = this.safeDict(currency, 'limits', {});
-            const depositLimits = this.safeDict(networkLimits, 'deposit', {});
-            const withdrawLimits = this.safeDict(networkLimits, 'withdraw', {});
-            const allNetworks = this.arrayConcat(depositsNetworks, withdrawsNetworks);
-            for (let j = 0; j < allNetworks.length; j++) {
-                const networkId = allNetworks[j];
-                const networkCode = this.networkIdToCode(networkId);
-                const networkDepositLimits = this.safeDict(depositLimits, networkId, {});
-                const networkWithdrawLimits = this.safeDict(withdrawLimits, networkId, {});
-                networks[networkCode] = {
-                    'id': networkId,
-                    'network': networkCode,
-                    'active': undefined,
-                    'deposit': this.inArray(networkId, depositsNetworks),
-                    'withdraw': this.inArray(networkId, withdrawsNetworks),
-                    'fee': undefined,
-                    'precision': undefined,
-                    'limits': {
-                        'deposit': {
-                            'min': this.safeNumber(networkDepositLimits, 'min'),
-                            'max': this.safeNumber(networkDepositLimits, 'max'),
-                        },
-                        'withdraw': {
-                            'min': this.safeNumber(networkWithdrawLimits, 'min'),
-                            'max': this.safeNumber(networkWithdrawLimits, 'max'),
-                        },
-                    },
-                };
-            }
-            result[code] = this.safeCurrencyStructure({
-                'id': id,
-                'code': code,
-                'info': currency,
-                'name': undefined,
+        const enhancedArray = this.addKeyInArrayItems(response, '_coin_id');
+        return this.parseCurrencies(enhancedArray);
+    }
+    parseCurrency(rawCurrency) {
+        // const name = this.safeString (currency, 'name'); // breaks down in Python due to utf8 encoding issues on the exchange side
+        const id = this.safeString(rawCurrency, '_coin_id');
+        const code = this.safeCurrencyCode(id);
+        const hasProvider = ('providers' in rawCurrency);
+        const networks = {};
+        const rawNetworks = this.safeDict(rawCurrency, 'networks', {});
+        const depositsNetworks = this.safeList(rawNetworks, 'deposits', []);
+        const withdrawsNetworks = this.safeList(rawNetworks, 'withdraws', []);
+        const networkLimits = this.safeDict(rawCurrency, 'limits', {});
+        const depositLimits = this.safeDict(networkLimits, 'deposit', {});
+        const withdrawLimits = this.safeDict(networkLimits, 'withdraw', {});
+        const allNetworks = this.arrayConcat(depositsNetworks, withdrawsNetworks);
+        for (let j = 0; j < allNetworks.length; j++) {
+            const networkId = allNetworks[j];
+            const networkCode = this.networkIdToCode(networkId, code);
+            const networkDepositLimits = this.safeDict(depositLimits, networkId, {});
+            const networkWithdrawLimits = this.safeDict(withdrawLimits, networkId, {});
+            networks[networkCode] = {
+                'id': networkId,
+                'network': networkCode,
                 'active': undefined,
-                'deposit': this.safeBool(currency, 'can_deposit'),
-                'withdraw': this.safeBool(currency, 'can_withdraw'),
+                'deposit': this.inArray(networkId, depositsNetworks),
+                'withdraw': this.inArray(networkId, withdrawsNetworks),
                 'fee': undefined,
-                'networks': networks,
-                'type': hasProvider ? 'fiat' : 'crypto',
-                'precision': this.parseNumber(this.parsePrecision(this.safeString(currency, 'currency_precision'))),
+                'precision': undefined,
                 'limits': {
-                    'amount': {
-                        'min': undefined,
-                        'max': undefined,
+                    'deposit': {
+                        'min': this.safeNumber(networkDepositLimits, 'min'),
+                        'max': this.safeNumber(networkDepositLimits, 'max'),
                     },
                     'withdraw': {
-                        'min': this.safeNumber(currency, 'min_withdraw'),
-                        'max': this.safeNumber(currency, 'max_withdraw'),
-                    },
-                    'deposit': {
-                        'min': this.safeNumber(currency, 'min_deposit'),
-                        'max': this.safeNumber(currency, 'max_deposit'),
+                        'min': this.safeNumber(networkWithdrawLimits, 'min'),
+                        'max': this.safeNumber(networkWithdrawLimits, 'max'),
                     },
                 },
-            });
+            };
         }
-        return result;
+        return this.safeCurrencyStructure({
+            'id': id,
+            'code': code,
+            'info': rawCurrency,
+            'name': undefined,
+            'active': undefined,
+            'deposit': this.safeBool(rawCurrency, 'can_deposit'),
+            'withdraw': this.safeBool(rawCurrency, 'can_withdraw'),
+            'fee': undefined,
+            'networks': networks,
+            'type': hasProvider ? 'fiat' : 'crypto',
+            'precision': this.parseNumber(this.parsePrecision(this.safeString(rawCurrency, 'currency_precision'))),
+            'limits': {
+                'amount': {
+                    'min': undefined,
+                    'max': undefined,
+                },
+                'withdraw': {
+                    'min': this.safeNumber(rawCurrency, 'min_withdraw'),
+                    'max': this.safeNumber(rawCurrency, 'max_withdraw'),
+                },
+                'deposit': {
+                    'min': this.safeNumber(rawCurrency, 'min_deposit'),
+                    'max': this.safeNumber(rawCurrency, 'max_deposit'),
+                },
+            },
+        });
     }
     /**
      * @method
@@ -901,7 +899,7 @@ class whitebit extends whitebit$1["default"] {
                 if (networkId !== undefined) {
                     const networkLength = networkId.length;
                     networkId = networkId.slice(1, networkLength - 1);
-                    const networkCode = this.networkIdToCode(networkId);
+                    const networkCode = this.networkIdToCode(networkId, code);
                     depositWithdrawFees[code]['networks'][networkCode] = {
                         'withdraw': withdrawResult,
                         'deposit': depositResult,