ccxt 4.5.82 → 4.5.83

package/dist/cjs/src/bitrue.js

@@ -856,7 +856,7 @@ class bitrue extends bitrue$1["default"] {
             }
         }
         const promises = await Promise.all(promisesRaw);
-        const spotMarkets = this.safeValue(this.safeValue(promises, 0), 'symbols', []);
+        const spotMarkets = this.safeList(this.safeDict(promises, 0), 'symbols', []);
         const futureMarkets = this.safeValue(promises, 1);
         const deliveryMarkets = this.safeValue(promises, 2);
         let markets = spotMarkets;
@@ -2124,7 +2124,7 @@ class bitrue extends bitrue$1["default"] {
                 request['volume'] = this.parseToNumeric(amount);
             }
             request['positionType'] = 1;
-            const reduceOnly = this.safeValue2(params, 'reduceOnly', 'reduce_only');
+            const reduceOnly = this.safeBool2(params, 'reduceOnly', 'reduce_only');
             request['open'] = (reduceOnly === true) ? 'CLOSE' : 'OPEN';
             const leverage = this.safeString(params, 'leverage', '1');
             request['leverage'] = this.parseToNumeric(leverage);
@@ -2149,7 +2149,7 @@ class bitrue extends bitrue$1["default"] {
                 params = this.omit(params, ['newClientOrderId', 'clientOrderId']);
                 request['newClientOrderId'] = clientOrderId;
             }
-            const triggerPrice = this.safeValue2(params, 'triggerPrice', 'stopPrice');
+            const triggerPrice = this.safeNumber2(params, 'triggerPrice', 'stopPrice');
             if (triggerPrice !== undefined) {
                 params = this.omit(params, ['triggerPrice', 'stopPrice']);
                 request['stopPrice'] = this.priceToPrecision(symbol, triggerPrice);
@@ -2202,7 +2202,7 @@ class bitrue extends bitrue$1["default"] {
             await this.loadMarkets();
         }
         const market = this.market(symbol);
-        const origClientOrderId = this.safeValue2(params, 'origClientOrderId', 'clientOrderId');
+        const origClientOrderId = this.safeString2(params, 'origClientOrderId', 'clientOrderId');
         params = this.omit(params, ['origClientOrderId', 'clientOrderId']);
         let response = undefined;
         let data = {};
@@ -2451,7 +2451,7 @@ class bitrue extends bitrue$1["default"] {
             await this.loadMarkets();
         }
         const market = this.market(symbol);
-        const origClientOrderId = this.safeValue2(params, 'origClientOrderId', 'clientOrderId');
+        const origClientOrderId = this.safeString2(params, 'origClientOrderId', 'clientOrderId');
         params = this.omit(params, ['origClientOrderId', 'clientOrderId']);
         let response = undefined;
         let data = {};
@@ -3435,7 +3435,7 @@ class bitrue extends bitrue$1["default"] {
                 }
             }
         }
-        return this.safeValue(config, 'cost', 1);
+        return this.safeNumber(config, 'cost', 1);
     }
 }
 

package/dist/cjs/src/bitso.js

@@ -330,7 +330,7 @@ class bitso extends bitso$1["default"] {
         //         }]
         //     }
         //
-        const payload = this.safeValue(response, 'payload', []);
+        const payload = this.safeList(response, 'payload', []);
         const currency = this.safeCurrency(code);
         return this.parseLedger(payload, currency, since, limit);
     }
@@ -400,15 +400,15 @@ class bitso extends bitso$1["default"] {
         //     }
         const operation = this.safeString(item, 'operation');
         const type = this.parseLedgerEntryType(operation);
-        const balanceUpdates = this.safeValue(item, 'balance_updates', []);
-        const firstBalance = this.safeValue(balanceUpdates, 0, {});
+        const balanceUpdates = this.safeList(item, 'balance_updates', []);
+        const firstBalance = this.safeDict(balanceUpdates, 0, {});
         let direction = undefined;
         let fee = undefined;
         const amount = this.safeString(firstBalance, 'amount');
         const currencyId = this.safeString(firstBalance, 'currency');
         const code = this.safeCurrencyCode(currencyId, currency);
         currency = this.safeCurrency(currencyId, currency);
-        const details = this.safeValue(item, 'details', {});
+        const details = this.safeDict(item, 'details', {});
         let referenceId = this.safeString2(details, 'fid', 'wid');
         if (referenceId === undefined) {
             referenceId = this.safeString(details, 'tid');
@@ -502,8 +502,8 @@ class bitso extends bitso$1["default"] {
             let quote = quoteId.toUpperCase();
             base = this.safeCurrencyCode(base);
             quote = this.safeCurrencyCode(quote);
-            const fees = this.safeValue(market, 'fees', {});
-            const flatRate = this.safeValue(fees, 'flat_rate', {});
+            const fees = this.safeDict(market, 'fees', {});
+            const flatRate = this.safeDict(fees, 'flat_rate', {});
             const takerString = this.safeString(flatRate, 'taker');
             const makerString = this.safeString(flatRate, 'maker');
             const taker = this.parseNumber(Precise["default"].stringDiv(takerString, '100'));
@@ -739,7 +739,7 @@ class bitso extends bitso$1["default"] {
             'book': market['id'],
         };
         const response = await this.publicGetOrderBook(this.extend(request, params));
-        const orderbook = this.safeValue(response, 'payload');
+        const orderbook = this.safeDict(response, 'payload');
         const timestamp = this.parse8601(this.safeString(orderbook, 'updated_at'));
         return this.parseOrderBook(orderbook, market['symbol'], timestamp, 'bids', 'asks', 'price', 'amount');
     }
@@ -1091,7 +1091,7 @@ class bitso extends bitso$1["default"] {
         //        }
         //    }
         //
-        const payload = this.safeValue(response, 'payload', {});
+        const payload = this.safeDict(response, 'payload', {});
         const fees = this.safeList(payload, 'fees', []);
         const result = {};
         for (let i = 0; i < fees.length; i++) {
@@ -1398,7 +1398,7 @@ class bitso extends bitso$1["default"] {
         const response = await this.privateGetOrdersOid({
             'oid': id,
         });
-        const payload = this.safeValue(response, 'payload');
+        const payload = this.safeList(response, 'payload');
         if (Array.isArray(payload)) {
             const numOrders = payload.length;
             if (numOrders === 1) {
@@ -1472,7 +1472,7 @@ class bitso extends bitso$1["default"] {
         //         }]
         //     }
         //
-        const transactions = this.safeValue(response, 'payload', []);
+        const transactions = this.safeList(response, 'payload', []);
         const first = this.safeDict(transactions, 0, {});
         return this.parseTransaction(first);
     }
@@ -1615,7 +1615,7 @@ class bitso extends bitso$1["default"] {
         //    }
         //
         const result = {};
-        const payload = this.safeValue(response, 'payload', {});
+        const payload = this.safeDict(response, 'payload', {});
         const depositFees = this.safeList(payload, 'deposit_fees', []);
         for (let i = 0; i < depositFees.length; i++) {
             const depositFee = depositFees[i];
@@ -1645,10 +1645,10 @@ class bitso extends bitso$1["default"] {
             }
             if (code !== undefined) {
                 result[code] = {
-                    'deposit': this.safeValue(this.safeValue(result, code), 'deposit'),
+                    'deposit': this.safeValue(this.safeDict(result, code), 'deposit'),
                     'withdraw': this.safeNumber(withdrawalFees, currencyId),
                     'info': {
-                        'deposit': this.safeValue(this.safeValue(this.safeValue(result, code), 'info'), 'deposit'),
+                        'deposit': this.safeValue(this.safeDict(this.safeDict(result, code), 'info'), 'deposit'),
                         'withdraw': this.safeNumber(withdrawalFees, currencyId),
                     },
                 };
@@ -1769,7 +1769,7 @@ class bitso extends bitso$1["default"] {
                     result[code] = {
                         'deposit': {
                             'fee': this.safeNumber(entry, 'fee'),
-                            'percentage': (this.safeValue(entry, 'is_fixed') !== true),
+                            'percentage': (this.safeBool(entry, 'is_fixed') !== true),
                         },
                         'withdraw': {
                             'fee': undefined,
@@ -1787,7 +1787,7 @@ class bitso extends bitso$1["default"] {
             const code = this.safeCurrencyCode(currencyId);
             if ((code !== undefined) && ((codes === undefined) || (code in codes))) {
                 const withdrawFee = this.parseNumber(withdrawalResponse[currencyId]);
-                const resultValue = this.safeValue(result, code);
+                const resultValue = this.safeDict(result, code);
                 if (resultValue === undefined) {
                     result[code] = this.depositWithdrawFee({});
                 }
@@ -1852,7 +1852,7 @@ class bitso extends bitso$1["default"] {
         //         ]
         //     }
         //
-        const payload = this.safeValue(response, 'payload', []);
+        const payload = this.safeList(response, 'payload', []);
         const first = this.safeDict(payload, 0);
         return this.parseTransaction(first, currency);
     }
@@ -1895,7 +1895,7 @@ class bitso extends bitso$1["default"] {
         //
         const currencyId = this.safeString2(transaction, 'currency', 'asset');
         currency = this.safeCurrency(currencyId, currency);
-        const details = this.safeValue(transaction, 'details', {});
+        const details = this.safeDict(transaction, 'details', {});
         const datetime = this.safeString(transaction, 'created_at');
         const withdrawalAddress = this.safeString(details, 'withdrawal_address');
         const receivingAddress = this.safeString(details, 'receiving_address');
@@ -1988,7 +1988,7 @@ class bitso extends bitso$1["default"] {
             }
             if (success !== true) {
                 const feedback = this.id + ' ' + this.json(response);
-                const error = this.safeValue(response, 'error');
+                const error = this.safeDict(response, 'error');
                 if (error === undefined) {
                     throw new errors.ExchangeError(feedback);
                 }

package/dist/cjs/src/bitstamp.js

@@ -791,7 +791,7 @@ class bitstamp extends bitstamp$1["default"] {
     async fetchMarketsFromCache(params = {}) {
         // this method is now redundant
         // currencies are now fetched before markets
-        const options = this.safeValue(this.options, 'fetchMarkets', {});
+        const options = this.safeDict(this.options, 'fetchMarkets', {});
         const timestamp = this.safeInteger(options, 'timestamp');
         const expires = this.safeInteger(options, 'expires', 1000);
         const now = this.milliseconds();
@@ -1391,7 +1391,7 @@ class bitstamp extends bitstamp$1["default"] {
         //         }
         //     }
         //
-        const data = this.safeValue(response, 'data', {});
+        const data = this.safeDict(response, 'data', {});
         const ohlc = this.safeList(data, 'ohlc', []);
         return this.parseOHLCVs(ohlc, market, timeframe, since, limit);
     }
@@ -1569,7 +1569,7 @@ class bitstamp extends bitstamp$1["default"] {
         const ids = Object.keys(currencies);
         for (let i = 0; i < ids.length; i++) {
             const id = ids[i];
-            const fees = this.safeValue(response, i, {});
+            const fees = this.safeDict(response, i, {});
             const code = this.safeCurrencyCode(id);
             if ((codes !== undefined) && !this.inArray(code, codes)) {
                 continue;
@@ -1970,7 +1970,7 @@ class bitstamp extends bitstamp$1["default"] {
         //         ]
         //     }
         //
-        const values = this.safeValue(response, 'funding_rate_history', []);
+        const values = this.safeList(response, 'funding_rate_history', []);
         return this.parseFundingRateHistories(values, market, since, limit);
     }
     parseFundingRateHistory(contract, market = undefined) {
@@ -2307,7 +2307,7 @@ class bitstamp extends bitstamp$1["default"] {
         const symbol = this.safeSymbol(marketId, market, '/');
         const status = this.parseOrderStatus(this.safeString(order, 'status'));
         const amount = this.safeString(order, 'amount');
-        const transactions = this.safeValue(order, 'transactions', []);
+        const transactions = this.safeList(order, 'transactions', []);
         const price = this.safeString(order, 'price');
         return this.safeOrder({
             'id': id,

package/dist/cjs/src/bitteam.js

@@ -452,8 +452,8 @@ class bitteam extends bitteam$1["default"] {
         //         }
         //     }
         //
-        const result = this.safeValue(response, 'result', {});
-        const markets = this.safeValue(result, 'pairs', []);
+        const result = this.safeDict(response, 'result', {});
+        const markets = this.safeList(result, 'pairs', []);
         return this.parseMarkets(markets);
     }
     parseMarket(market) {
@@ -464,14 +464,14 @@ class bitteam extends bitteam$1["default"] {
         const quoteId = this.safeString(parts, 1);
         const base = this.safeCurrencyCode(baseId);
         const quote = this.safeCurrencyCode(quoteId);
-        const active = this.safeValue(market, 'active');
+        const active = this.safeBool(market, 'active');
         const timeStart = this.safeString(market, 'timeStart');
         const created = this.parse8601(timeStart);
         let minCost = undefined;
         const currenciesValuedInUsd = this.handleOption('fetchMarkets', 'currenciesValuedInUsd', {});
         const quoteInUsd = this.safeBool(currenciesValuedInUsd, quote, false);
         if (quoteInUsd === true) {
-            const settings = this.safeValue(market, 'settings', {});
+            const settings = this.safeDict(market, 'settings', {});
             minCost = this.safeNumber(settings, 'limit_usd');
         }
         return this.safeMarketStructure({
@@ -625,8 +625,8 @@ class bitteam extends bitteam$1["default"] {
         //         }
         //     }
         //
-        const responseResult = this.safeValue(response, 'result', {});
-        const currencies = this.safeValue(responseResult, 'currencies', []);
+        const responseResult = this.safeDict(response, 'result', {});
+        const currencies = this.safeList(responseResult, 'currencies', []);
         // using another endpoint to fetch statuses of deposits and withdrawals
         let statusesResponse = await this.publicGetTradeApiCmcAssets();
         //
@@ -656,18 +656,18 @@ class bitteam extends bitteam$1["default"] {
         return result;
     }
     parseCurrency(currency) {
-        const statusesResponse = this.safeValue(this.options, '_temp_currencies_statuses', {});
+        const statusesResponse = this.safeDict(this.options, '_temp_currencies_statuses', {});
         const id = this.safeString(currency, 'symbol');
         const numericId = this.safeInteger(currency, 'id');
         const code = this.safeCurrencyCode(id);
         const active = this.safeBool(currency, 'active', false);
         const precision = this.parseNumber(this.parsePrecision(this.safeString(currency, 'precision')));
-        const txLimits = this.safeValue(currency, 'txLimits', {});
+        const txLimits = this.safeDict(currency, 'txLimits', {});
         const minWithdraw = this.safeString(txLimits, 'minWithdraw');
         const maxWithdraw = this.safeString(txLimits, 'maxWithdraw');
         const minDeposit = this.safeString(txLimits, 'minDeposit');
         let fee = undefined;
-        const withdrawCommissionFixed = this.safeValue(txLimits, 'withdrawCommissionFixed', {});
+        const withdrawCommissionFixed = this.safeDict(txLimits, 'withdrawCommissionFixed', {});
         let feesByNetworkId = {};
         const blockChain = this.safeString(currency, 'blockChain');
         // if only one blockChain
@@ -678,9 +678,9 @@ class bitteam extends bitteam$1["default"] {
         else {
             feesByNetworkId = withdrawCommissionFixed;
         }
-        const statuses = this.safeValue(statusesResponse, numericId, {});
-        const deposit = this.safeValue(statuses, 'depositStatus');
-        const withdraw = this.safeValue(statuses, 'withdrawStatus');
+        const statuses = this.safeDict(statusesResponse, numericId, {});
+        const deposit = this.safeBool(statuses, 'depositStatus');
+        const withdraw = this.safeBool(statuses, 'withdrawStatus');
         const networkIds = Object.keys(feesByNetworkId);
         const networks = {};
         const networkPrecision = this.parseNumber(this.parsePrecision(this.safeString(currency, 'decimals')));
@@ -794,7 +794,7 @@ class bitteam extends bitteam$1["default"] {
         //         }
         //     }
         //
-        const result = this.safeValue(response, 'result', {});
+        const result = this.safeDict(response, 'result', {});
         const data = this.safeList(result, 'data', []);
         return this.parseOHLCVs(data, market, timeframe, since, limit);
     }
@@ -979,7 +979,7 @@ class bitteam extends bitteam$1["default"] {
         //         }
         //     }
         //
-        const result = this.safeValue(response, 'result', {});
+        const result = this.safeDict(response, 'result', {});
         const orders = this.safeList(result, 'orders', []);
         return this.parseOrders(orders, market, since, limit);
     }
@@ -1224,7 +1224,7 @@ class bitteam extends bitteam$1["default"] {
         //         }
         //     }
         //
-        const result = this.safeValue(response, 'result', {});
+        const result = this.safeDict(response, 'result', {});
         const orders = [result];
         return this.parseOrders(orders, market);
     }
@@ -1331,7 +1331,7 @@ class bitteam extends bitteam$1["default"] {
         const status = this.parseOrderStatus(this.safeString(order, 'status'));
         const type = this.parseOrderType(this.safeString(order, 'type'));
         const side = this.safeString(order, 'side');
-        const feeRaw = this.safeValue(order, 'fee');
+        const feeRaw = this.safeDict(order, 'fee');
         const price = this.safeString(order, 'price');
         const amount = this.safeString(order, 'quantity');
         const filled = this.safeString(order, 'executed');
@@ -1657,7 +1657,7 @@ class bitteam extends bitteam$1["default"] {
         //         }
         //     }
         //
-        const result = this.safeValue(response, 'result', {});
+        const result = this.safeDict(response, 'result', {});
         const pair = this.safeDict(result, 'pair', {});
         return this.parseTicker(pair, market);
     }
@@ -1747,13 +1747,13 @@ class bitteam extends bitteam$1["default"] {
         let bestAskPrice = undefined;
         let bestBidVolume = undefined;
         let bestAskVolume = undefined;
-        const bids = this.safeValue(ticker, 'bids');
-        const asks = this.safeValue(ticker, 'asks');
+        const bids = this.safeList(ticker, 'bids');
+        const asks = this.safeList(ticker, 'asks');
         if ((bids !== undefined) && (Array.isArray(bids)) && (asks !== undefined) && (Array.isArray(asks))) {
-            const bestBid = this.safeValue(bids, 0, {});
+            const bestBid = this.safeDict(bids, 0, {});
             bestBidPrice = this.safeString(bestBid, 'price');
             bestBidVolume = this.safeString(bestBid, 'quantity');
-            const bestAsk = this.safeValue(asks, 0, {});
+            const bestAsk = this.safeDict(asks, 0, {});
             bestAskPrice = this.safeString(bestAsk, 'price');
             bestAskVolume = this.safeString(bestAsk, 'quantity');
         }
@@ -1990,7 +1990,7 @@ class bitteam extends bitteam$1["default"] {
         //         }
         //     }
         //
-        const result = this.safeValue(response, 'result', {});
+        const result = this.safeDict(response, 'result', {});
         const trades = this.safeList(result, 'trades', []);
         return this.parseTrades(trades, market, since, limit);
     }
@@ -2073,11 +2073,11 @@ class bitteam extends bitteam$1["default"] {
                 side = 'sell';
             }
             order = this.safeString(trade, 'makerOrderId');
-            feeInfo = this.safeValue(trade, 'feeMaker', {});
+            feeInfo = this.safeDict(trade, 'feeMaker', {});
         }
         else if (takerOrMaker === 'taker') {
             order = this.safeString(trade, 'takerOrderId');
-            feeInfo = this.safeValue(trade, 'feeTaker', {});
+            feeInfo = this.safeDict(trade, 'feeTaker', {});
         }
         const feeCurrencyId = this.safeString(feeInfo, 'symbol');
         const feeCost = this.safeString(feeInfo, 'amount');
@@ -2164,12 +2164,12 @@ class bitteam extends bitteam$1["default"] {
             'timestamp': undefined,
             'datetime': undefined,
         };
-        const result = this.safeValue(response, 'result', {});
+        const result = this.safeDict(response, 'result', {});
         const balanceByCurrencies = this.omit(result, ['free', 'used', 'total']);
         const rawCurrencyIds = Object.keys(balanceByCurrencies);
         for (let i = 0; i < rawCurrencyIds.length; i++) {
             const rawCurrencyId = rawCurrencyIds[i];
-            const currencyBalance = this.safeValue(result, rawCurrencyId);
+            const currencyBalance = this.safeDict(result, rawCurrencyId);
             const free = this.safeString(currencyBalance, 'free');
             const used = this.safeString(currencyBalance, 'used');
             const total = this.safeString(currencyBalance, 'total');
@@ -2297,7 +2297,7 @@ class bitteam extends bitteam$1["default"] {
         //         }
         //     }
         //
-        const result = this.safeValue(response, 'result', {});
+        const result = this.safeDict(response, 'result', {});
         const transactions = this.safeList(result, 'transactions', []);
         return this.parseTransactions(transactions, currency, since, limit);
     }
@@ -2349,17 +2349,17 @@ class bitteam extends bitteam$1["default"] {
         //         }
         //     }
         //
-        const currencyObject = this.safeValue(transaction, 'currency');
+        const currencyObject = this.safeDict(transaction, 'currency');
         const currencyId = this.safeString(currencyObject, 'symbol');
         const code = this.safeCurrencyCode(currencyId, currency);
         const id = this.safeString(transaction, 'id');
-        const params = this.safeValue(transaction, 'params');
+        const params = this.safeDict(transaction, 'params');
         const txid = this.safeString(params, 'tx_id');
         const timestamp = this.safeInteger(transaction, 'timestamp');
         let networkId = this.safeString(transaction, 'blockChain');
         if (networkId === undefined) {
-            const links = this.safeValue(currencyObject, 'links', []);
-            const blockChain = this.safeValue(links, 0, {});
+            const links = this.safeList(currencyObject, 'links', []);
+            const blockChain = this.safeDict(links, 0, {});
             networkId = this.safeString(blockChain, 'blockChain');
         }
         const addressFrom = this.safeString(transaction, 'sender');
@@ -2367,7 +2367,7 @@ class bitteam extends bitteam$1["default"] {
         const tag = this.safeString(transaction, 'message');
         const type = this.parseTransactionType(this.safeString(transaction, 'type'));
         const amount = this.parseValueToPricision(transaction, 'amount', currencyObject, 'decimals');
-        const status = this.parseTransactionStatus(this.safeValue(transaction, 'status'));
+        const status = this.parseTransactionStatus(this.safeString(transaction, 'status'));
         return {
             'info': transaction,
             'id': id,

package/dist/cjs/src/bittrade.js

@@ -476,7 +476,7 @@ class bittrade extends bittrade$1["default"] {
         //                 "market-sell-order-rate-must-less-than":  0.1,
         //                  "market-buy-order-rate-must-less-than":  0.1        } }
         //
-        return this.parseTradingLimits(this.safeValue(response, 'data', {}));
+        return this.parseTradingLimits(this.safeDict(response, 'data', {}));
     }
     parseTradingLimits(limits, symbol = undefined, params = {}) {
         //
@@ -765,7 +765,7 @@ class bittrade extends bittrade$1["default"] {
             if ((response['tick'] === undefined) || (response['tick'] === null)) {
                 throw new errors.BadSymbol(this.id + ' fetchOrderBook() returned empty response: ' + this.json(response));
             }
-            const tick = this.safeValue(response, 'tick');
+            const tick = this.safeDict(response, 'tick');
             const timestamp = this.safeInteger(tick, 'ts', this.safeInteger(response, 'ts'));
             const result = this.parseOrderBook(tick, symbol, timestamp);
             result['nonce'] = this.safeInteger(tick, 'version');
@@ -1165,15 +1165,15 @@ class bittrade extends bittrade$1["default"] {
         //         ]
         //     }
         //
-        const currencies = this.safeValue(response, 'data', []);
+        const currencies = this.safeList(response, 'data', []);
         return this.parseCurrencies(currencies);
     }
     parseCurrency(currency) {
-        const id = this.safeValue(currency, 'name');
+        const id = this.safeString(currency, 'name');
         const code = this.safeCurrencyCode(id);
-        const depositEnabled = this.safeValue(currency, 'deposit-enabled');
-        const withdrawEnabled = this.safeValue(currency, 'withdraw-enabled');
-        const countryDisabled = this.safeValue(currency, 'country-disabled');
+        const depositEnabled = this.safeBool(currency, 'deposit-enabled');
+        const withdrawEnabled = this.safeBool(currency, 'withdraw-enabled');
+        const countryDisabled = this.safeBool(currency, 'country-disabled');
         const visible = this.safeBool(currency, 'visible', false);
         const state = this.safeString(currency, 'state');
         const active = (visible === true) && (depositEnabled === true) && (withdrawEnabled === true) && (state === 'online') && (countryDisabled !== true);
@@ -1567,7 +1567,7 @@ class bittrade extends bittrade$1["default"] {
         };
         const clientOrderId = this.safeString2(params, 'clientOrderId', 'client-order-id'); // must be 64 chars max and unique within 24 hours
         if (clientOrderId === undefined) {
-            const broker = this.safeValue(this.options, 'broker', {});
+            const broker = this.safeDict(this.options, 'broker', {});
             const brokerId = this.safeString(broker, 'id');
             request['client-order-id'] = brokerId + this.uuid();
         }
@@ -1835,7 +1835,7 @@ class bittrade extends bittrade$1["default"] {
         currency = this.safeCurrency(currencyId, currency);
         const code = this.safeCurrencyCode(currencyId, currency);
         const networkId = this.safeString(depositAddress, 'chain');
-        const networks = this.safeValue(currency, 'networks', {});
+        const networks = this.safeDict(currency, 'networks', {});
         const networksById = this.indexBy(networks, 'id');
         const networkValue = this.safeValue(networksById, networkId, networkId);
         const network = this.safeString(networkValue, 'network');
@@ -2049,7 +2049,7 @@ class bittrade extends bittrade$1["default"] {
         if (tag !== undefined) {
             request['addr-tag'] = tag; // only for XRP?
         }
-        const networks = this.safeValue(this.options, 'networks', {});
+        const networks = this.safeDict(this.options, 'networks', {});
         let network = this.safeStringUpper(params, 'network'); // this line allows the user to specify either ERC20 or ETH
         network = this.safeStringLower(networks, network, network); // handle ETH>ERC20 alias
         if (network !== undefined) {

package/dist/cjs/src/bitvavo.js

@@ -912,7 +912,7 @@ class bitvavo extends bitvavo$1["default"] {
         const id = this.safeString2(trade, 'id', 'fillId');
         const marketId = this.safeString(trade, 'market');
         const symbol = this.safeSymbol(marketId, market, '-');
-        const taker = this.safeValue(trade, 'taker');
+        const taker = this.safeBool(trade, 'taker');
         let takerOrMaker = undefined;
         if (taker !== undefined) {
             takerOrMaker = (taker === true) ? 'taker' : 'maker';
@@ -978,7 +978,7 @@ class bitvavo extends bitvavo$1["default"] {
         //         }
         //     }
         //
-        const feesValue = this.safeValue(fees, 'fees');
+        const feesValue = this.safeDict(fees, 'fees');
         const maker = this.safeNumber(feesValue, 'maker');
         const taker = this.safeNumber(feesValue, 'taker');
         const result = {};
@@ -1118,7 +1118,7 @@ class bitvavo extends bitvavo$1["default"] {
         }
         [request, params] = this.handleUntilOption('end', request, params);
         if (limit !== undefined) {
-            request['limit'] = limit; // default 1440, max 1440
+            request['limit'] = Math.min(limit, 1440); // default 1440, max 1440
         }
         return this.extend(request, params);
     }
@@ -1488,8 +1488,8 @@ class bitvavo extends bitvavo$1["default"] {
         const timeInForce = this.safeString(params, 'timeInForce');
         let triggerPrice = this.safeStringN(params, ['triggerPrice', 'stopPrice', 'triggerAmount']);
         const postOnly = this.isPostOnly(isMarketOrder, false, params);
-        const stopLossPrice = this.safeValue(params, 'stopLossPrice'); // trigger when price crosses from above to below this value
-        const takeProfitPrice = this.safeValue(params, 'takeProfitPrice'); // trigger when price crosses from below to above this value
+        const stopLossPrice = this.safeString(params, 'stopLossPrice'); // trigger when price crosses from above to below this value
+        const takeProfitPrice = this.safeString(params, 'takeProfitPrice'); // trigger when price crosses from below to above this value
         params = this.omit(params, ['timeInForce', 'triggerPrice', 'stopPrice', 'stopLossPrice', 'takeProfitPrice']);
         if (isMarketOrder) {
             let cost = undefined;
@@ -2112,7 +2112,7 @@ class bitvavo extends bitvavo$1["default"] {
                 'currency': feeCurrencyCode,
             };
         }
-        const rawTrades = this.safeValue(order, 'fills', []);
+        const rawTrades = this.safeList(order, 'fills', []);
         const timeInForce = this.safeString(order, 'timeInForce');
         const postOnly = this.safeValue(order, 'postOnly');
         // https://github.com/ccxt/ccxt/issues/8489
@@ -2597,8 +2597,8 @@ class bitvavo extends bitvavo$1["default"] {
             },
             'networks': {},
         };
-        const networks = this.safeValue(fee, 'networks');
-        let networkId = this.safeValue(networks, 0); // Bitvavo currently only supports one network per currency
+        const networks = this.safeList(fee, 'networks');
+        let networkId = this.safeString(networks, 0); // Bitvavo currently only supports one network per currency
         const currencyCode = this.safeString(currency, 'code');
         if (networkId === 'Mainnet') {
             networkId = currencyCode;
@@ -2705,7 +2705,7 @@ class bitvavo extends bitvavo$1["default"] {
         if (('noMarket' in config) && !('market' in params)) {
             return config['noMarket'];
         }
-        return this.safeValue(config, 'cost', 1);
+        return this.safeNumber(config, 'cost', 1);
     }
 }
 

package/dist/cjs/src/blockchaincom.js

@@ -331,7 +331,7 @@ class blockchaincom extends blockchaincom$1["default"] {
         const result = [];
         for (let i = 0; i < marketIds.length; i++) {
             const marketId = marketIds[i];
-            const market = this.safeValue(markets, marketId);
+            const market = this.safeDict(markets, marketId);
             const baseId = this.safeString(market, 'base_currency');
             const quoteId = this.safeString(market, 'counter_currency');
             const base = this.safeCurrencyCode(baseId);
@@ -1190,7 +1190,7 @@ class blockchaincom extends blockchaincom$1["default"] {
         //         ]
         //     }
         //
-        const balances = this.safeValue(response, accountName);
+        const balances = this.safeList(response, accountName);
         if (balances === undefined) {
             throw new errors.ExchangeError(this.id + ' fetchBalance() could not find the "' + accountName + '" account');
         }

package/dist/cjs/src/btcbox.js

@@ -835,11 +835,11 @@ class btcbox extends btcbox$1["default"] {
         if (httpCode >= 400) {
             return undefined; // resort to defaultErrorHandler
         }
-        const result = this.safeValue(response, 'result');
+        const result = this.safeBool(response, 'result');
         if (result === undefined || result === true) {
             return undefined; // either public API (no error codes expected) or success
         }
-        const code = this.safeValue(response, 'code');
+        const code = this.safeString(response, 'code');
         const feedback = this.id + ' ' + body;
         this.throwExactlyMatchedException(this.exceptions, code, feedback);
         throw new errors.ExchangeError(feedback); // unknown message

package/dist/cjs/src/btcmarkets.js

@@ -520,7 +520,7 @@ class btcmarkets extends btcmarkets$1["default"] {
         const base = this.safeCurrencyCode(baseId);
         const quote = this.safeCurrencyCode(quoteId);
         const symbol = base + '/' + quote;
-        const fees = this.safeValue(this.safeDict(this.options, 'fees', {}), quote, this.fees);
+        const fees = this.safeDict(this.safeDict(this.options, 'fees', {}), quote, this.fees);
         const pricePrecision = this.parseNumber(this.parsePrecision(this.safeString(market, 'priceDecimals')));
         const minAmount = this.safeNumber(market, 'minOrderAmount');
         const maxAmount = this.safeNumber(market, 'maxOrderAmount');
@@ -956,7 +956,7 @@ class btcmarkets extends btcmarkets$1["default"] {
             // 'clientOrderId': this.uuid (),
         };
         const lowercaseType = type.toLowerCase();
-        const orderTypes = this.safeValue(this.options, 'orderTypes', {
+        const orderTypes = this.safeDict(this.options, 'orderTypes', {
             'limit': 'Limit',
             'market': 'Market',
             'stop': 'Stop',