ccxt 4.3.7 → 4.3.8

package/README.md

@@ -213,13 +213,13 @@ console.log(version, Object.keys(exchanges));
 
 All-in-one browser bundle (dependencies included), served from a CDN of your choice:
 
-* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@4.3.7/dist/ccxt.browser.js
-* unpkg: https://unpkg.com/ccxt@4.3.7/dist/ccxt.browser.js
+* jsDelivr: https://cdn.jsdelivr.net/npm/ccxt@4.3.8/dist/ccxt.browser.js
+* unpkg: https://unpkg.com/ccxt@4.3.8/dist/ccxt.browser.js
 
 CDNs are not updated in real-time and may have delays. Defaulting to the most recent version without specifying the version number is not recommended. Please, keep in mind that we are not responsible for the correct operation of those CDN servers.
 
 ```HTML
-<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@4.3.7/dist/ccxt.browser.js"></script>
+<script type="text/javascript" src="https://cdn.jsdelivr.net/npm/ccxt@4.3.8/dist/ccxt.browser.js"></script>
 ```
 
 Creates a global `ccxt` object:

package/dist/cjs/ccxt.js

@@ -182,7 +182,7 @@ var woo$1 = require('./src/pro/woo.js');
 
 //-----------------------------------------------------------------------------
 // this is updated by vss.js when building
-const version = '4.3.7';
+const version = '4.3.8';
 Exchange["default"].ccxtVersion = version;
 const exchanges = {
     'ace': ace,

package/dist/cjs/src/base/Exchange.js

@@ -6104,7 +6104,7 @@ class Exchange {
     parseLeverage(leverage, market = undefined) {
         throw new errors.NotSupported(this.id + ' parseLeverage () is not supported yet');
     }
-    parseConversions(conversions, fromCurrencyKey = undefined, toCurrencyKey = undefined, since = undefined, limit = undefined, params = {}) {
+    parseConversions(conversions, code = undefined, fromCurrencyKey = undefined, toCurrencyKey = undefined, since = undefined, limit = undefined, params = {}) {
         conversions = this.toArray(conversions);
         const result = [];
         let fromCurrency = undefined;
@@ -6123,8 +6123,18 @@ class Exchange {
             result.push(conversion);
         }
         const sorted = this.sortBy(result, 'timestamp');
-        const code = (fromCurrency !== undefined) ? fromCurrency['code'] : undefined;
-        return this.filterByCurrencySinceLimit(sorted, code, since, limit);
+        let currency = undefined;
+        if (code !== undefined) {
+            currency = this.currency(code);
+            code = currency['code'];
+        }
+        if (code === undefined) {
+            return this.filterBySinceLimit(sorted, since, limit);
+        }
+        const fromConversion = this.filterBy(sorted, 'fromCurrency', code);
+        const toConversion = this.filterBy(sorted, 'toCurrency', code);
+        const both = this.arrayConcat(fromConversion, toConversion);
+        return this.filterBySinceLimit(both, since, limit);
     }
     parseConversion(conversion, fromCurrency = undefined, toCurrency = undefined) {
         throw new errors.NotSupported(this.id + ' parseConversion () is not supported yet');

package/dist/cjs/src/binance.js

@@ -12919,7 +12919,7 @@ class binance extends binance$1 {
             //
         }
         const rows = this.safeList(response, responseQuery, []);
-        return this.parseConversions(rows, fromCurrencyKey, toCurrencyKey, since, limit);
+        return this.parseConversions(rows, code, fromCurrencyKey, toCurrencyKey, since, limit);
     }
     parseConversion(conversion, fromCurrency = undefined, toCurrency = undefined) {
         //

package/dist/cjs/src/bingx.js

@@ -2463,7 +2463,7 @@ class bingx extends bingx$1 {
         return this.safeOrder({
             'info': info,
             'id': this.safeString2(order, 'orderId', 'i'),
-            'clientOrderId': this.safeStringN(order, ['clientOrderID', 'origClientOrderId', 'c']),
+            'clientOrderId': this.safeStringN(order, ['clientOrderID', 'clientOrderId', 'origClientOrderId', 'c']),
             'symbol': this.safeSymbol(marketId, market, '-', marketType),
             'timestamp': timestamp,
             'datetime': this.iso8601(timestamp),

package/dist/cjs/src/bitget.js

@@ -8672,7 +8672,7 @@ class bitget extends bitget$1 {
         //
         const data = this.safeDict(response, 'data', {});
         const dataList = this.safeList(data, 'dataList', []);
-        return this.parseConversions(dataList, 'fromCoin', 'toCoin', since, limit);
+        return this.parseConversions(dataList, code, 'fromCoin', 'toCoin', since, limit);
     }
     parseConversion(conversion, fromCurrency = undefined, toCurrency = undefined) {
         //

package/dist/cjs/src/coinex.js

@@ -1529,190 +1529,144 @@ class coinex extends coinex$1 {
     }
     async fetchMarginBalance(params = {}) {
         await this.loadMarkets();
-        const symbol = this.safeString(params, 'symbol');
-        let marketId = this.safeString(params, 'market');
-        let market = undefined;
-        if (symbol !== undefined) {
-            market = this.market(symbol);
-            marketId = market['id'];
-        }
-        else if (marketId === undefined) {
-            throw new errors.ArgumentsRequired(this.id + ' fetchMarginBalance() fetching a margin account requires a market parameter or a symbol parameter');
-        }
-        params = this.omit(params, ['symbol', 'market']);
-        const request = {
-            'market': marketId,
-        };
-        const response = await this.v1PrivateGetMarginAccount(this.extend(request, params));
+        const response = await this.v2PrivateGetAssetsMarginBalance(params);
         //
-        //      {
-        //          "code":    0,
-        //           "data": {
-        //              "account_id":    126,
-        //              "leverage":    3,
-        //              "market_type":   "AAVEUSDT",
-        //              "sell_asset_type":   "AAVE",
-        //              "buy_asset_type":   "USDT",
-        //              "balance": {
-        //                  "sell_type": "0.3",     // borrowed
-        //                  "buy_type": "30"
-        //                  },
-        //              "frozen": {
-        //                  "sell_type": "0",
-        //                  "buy_type": "0"
-        //                  },
-        //              "loan": {
-        //                  "sell_type": "0.3", // loan
-        //                  "buy_type": "0"
-        //                  },
-        //              "interest": {
-        //                  "sell_type": "0.0000125",
-        //                  "buy_type": "0"
-        //                  },
-        //              "can_transfer": {
-        //                  "sell_type": "0.02500646",
-        //                  "buy_type": "4.28635738"
-        //                  },
-        //              "warn_rate":   "",
-        //              "liquidation_price":   ""
-        //              },
-        //          "message": "Success"
-        //      }
+        //     {
+        //         "data": [
+        //             {
+        //                 "margin_account": "BTCUSDT",
+        //                 "base_ccy": "BTC",
+        //                 "quote_ccy": "USDT",
+        //                 "available": {
+        //                     "base_ccy": "0.00000026",
+        //                     "quote_ccy": "0"
+        //                 },
+        //                 "frozen": {
+        //                     "base_ccy": "0",
+        //                     "quote_ccy": "0"
+        //                 },
+        //                 "repaid": {
+        //                     "base_ccy": "0",
+        //                     "quote_ccy": "0"
+        //                 },
+        //                 "interest": {
+        //                     "base_ccy": "0",
+        //                     "quote_ccy": "0"
+        //                 },
+        //                 "rik_rate": "",
+        //                 "liq_price": ""
+        //             },
+        //         ],
+        //         "code": 0,
+        //         "message": "OK"
+        //     }
         //
         const result = { 'info': response };
-        const data = this.safeValue(response, 'data', {});
-        const free = this.safeValue(data, 'can_transfer', {});
-        const total = this.safeValue(data, 'balance', {});
-        const loan = this.safeValue(data, 'loan', {});
-        const interest = this.safeValue(data, 'interest', {});
-        //
-        const sellAccount = this.account();
-        const sellCurrencyId = this.safeString(data, 'sell_asset_type');
-        const sellCurrencyCode = this.safeCurrencyCode(sellCurrencyId);
-        sellAccount['free'] = this.safeString(free, 'sell_type');
-        sellAccount['total'] = this.safeString(total, 'sell_type');
-        const sellDebt = this.safeString(loan, 'sell_type');
-        const sellInterest = this.safeString(interest, 'sell_type');
-        sellAccount['debt'] = Precise["default"].stringAdd(sellDebt, sellInterest);
-        result[sellCurrencyCode] = sellAccount;
-        //
-        const buyAccount = this.account();
-        const buyCurrencyId = this.safeString(data, 'buy_asset_type');
-        const buyCurrencyCode = this.safeCurrencyCode(buyCurrencyId);
-        buyAccount['free'] = this.safeString(free, 'buy_type');
-        buyAccount['total'] = this.safeString(total, 'buy_type');
-        const buyDebt = this.safeString(loan, 'buy_type');
-        const buyInterest = this.safeString(interest, 'buy_type');
-        buyAccount['debt'] = Precise["default"].stringAdd(buyDebt, buyInterest);
-        result[buyCurrencyCode] = buyAccount;
-        //
+        const balances = this.safeList(response, 'data', []);
+        for (let i = 0; i < balances.length; i++) {
+            const entry = balances[i];
+            const free = this.safeDict(entry, 'available', {});
+            const used = this.safeDict(entry, 'frozen', {});
+            const loan = this.safeDict(entry, 'repaid', {});
+            const interest = this.safeDict(entry, 'interest', {});
+            const baseAccount = this.account();
+            const baseCurrencyId = this.safeString(entry, 'base_ccy');
+            const baseCurrencyCode = this.safeCurrencyCode(baseCurrencyId);
+            baseAccount['free'] = this.safeString(free, 'base_ccy');
+            baseAccount['used'] = this.safeString(used, 'base_ccy');
+            const baseDebt = this.safeString(loan, 'base_ccy');
+            const baseInterest = this.safeString(interest, 'base_ccy');
+            baseAccount['debt'] = Precise["default"].stringAdd(baseDebt, baseInterest);
+            result[baseCurrencyCode] = baseAccount;
+        }
         return this.safeBalance(result);
     }
     async fetchSpotBalance(params = {}) {
         await this.loadMarkets();
-        const response = await this.v1PrivateGetBalanceInfo(params);
+        const response = await this.v2PrivateGetAssetsSpotBalance(params);
         //
         //     {
-        //       "code": 0,
-        //       "data": {
-        //         "BCH": {                     # BCH account
-        //           "available": "13.60109",   # Available BCH
-        //           "frozen": "0.00000"        # Frozen BCH
-        //         },
-        //         "BTC": {                     # BTC account
-        //           "available": "32590.16",   # Available BTC
-        //           "frozen": "7000.00"        # Frozen BTC
-        //         },
-        //         "ETH": {                     # ETH account
-        //           "available": "5.06000",    # Available ETH
-        //           "frozen": "0.00000"        # Frozen ETH
-        //         }
-        //       },
-        //       "message": "Ok"
+        //         "code": 0,
+        //         "data": [
+        //             {
+        //                 "available": "0.00000046",
+        //                 "ccy": "USDT",
+        //                 "frozen": "0"
+        //             }
+        //         ],
+        //         "message": "OK"
         //     }
         //
         const result = { 'info': response };
-        const balances = this.safeValue(response, 'data', {});
-        const currencyIds = Object.keys(balances);
-        for (let i = 0; i < currencyIds.length; i++) {
-            const currencyId = currencyIds[i];
+        const balances = this.safeList(response, 'data', []);
+        for (let i = 0; i < balances.length; i++) {
+            const entry = balances[i];
+            const currencyId = this.safeString(entry, 'ccy');
             const code = this.safeCurrencyCode(currencyId);
-            const balance = this.safeValue(balances, currencyId, {});
             const account = this.account();
-            account['free'] = this.safeString(balance, 'available');
-            account['used'] = this.safeString(balance, 'frozen');
+            account['free'] = this.safeString(entry, 'available');
+            account['used'] = this.safeString(entry, 'frozen');
             result[code] = account;
         }
         return this.safeBalance(result);
     }
     async fetchSwapBalance(params = {}) {
         await this.loadMarkets();
-        const response = await this.v1PerpetualPrivateGetAssetQuery(params);
+        const response = await this.v2PrivateGetAssetsFuturesBalance(params);
         //
         //     {
         //         "code": 0,
-        //         "data": {
-        //             "USDT": {
-        //                 "available": "37.24817690383456000000",
-        //                 "balance_total": "37.24817690383456000000",
-        //                 "frozen": "0.00000000000000000000",
-        //                 "margin": "0.00000000000000000000",
-        //                 "profit_unreal": "0.00000000000000000000",
-        //                 "transfer": "37.24817690383456000000"
+        //         "data": [
+        //             {
+        //                 "available": "0.00000046",
+        //                 "ccy": "USDT",
+        //                 "frozen": "0",
+        //                 "margin": "0",
+        //                 "transferrable": "0.00000046",
+        //                 "unrealized_pnl": "0"
         //             }
-        //         },
+        //         ],
         //         "message": "OK"
         //     }
         //
         const result = { 'info': response };
-        const balances = this.safeValue(response, 'data', {});
-        const currencyIds = Object.keys(balances);
-        for (let i = 0; i < currencyIds.length; i++) {
-            const currencyId = currencyIds[i];
+        const balances = this.safeList(response, 'data', []);
+        for (let i = 0; i < balances.length; i++) {
+            const entry = balances[i];
+            const currencyId = this.safeString(entry, 'ccy');
             const code = this.safeCurrencyCode(currencyId);
-            const balance = this.safeValue(balances, currencyId, {});
             const account = this.account();
-            account['free'] = this.safeString(balance, 'available');
-            account['used'] = this.safeString(balance, 'frozen');
-            account['total'] = this.safeString(balance, 'balance_total');
+            account['free'] = this.safeString(entry, 'available');
+            account['used'] = this.safeString(entry, 'frozen');
             result[code] = account;
         }
         return this.safeBalance(result);
     }
     async fetchFinancialBalance(params = {}) {
         await this.loadMarkets();
-        const response = await this.v1PrivateGetAccountInvestmentBalance(params);
+        const response = await this.v2PrivateGetAssetsFinancialBalance(params);
         //
         //     {
-        //          "code": 0,
-        //          "data": [
-        //              {
-        //                  "asset": "CET",
-        //                  "available": "0",
-        //                  "frozen": "0",
-        //                  "lock": "0",
-        //              },
-        //              {
-        //                  "asset": "USDT",
-        //                  "available": "999900",
-        //                  "frozen": "0",
-        //                  "lock": "0"
-        //              }
-        //          ],
-        //          "message": "Success"
-        //      }
+        //         "code": 0,
+        //         "data": [
+        //             {
+        //                 "available": "0.00000046",
+        //                 "ccy": "USDT",
+        //                 "frozen": "0"
+        //             }
+        //         ],
+        //         "message": "OK"
+        //     }
         //
         const result = { 'info': response };
-        const balances = this.safeValue(response, 'data', {});
+        const balances = this.safeList(response, 'data', []);
         for (let i = 0; i < balances.length; i++) {
-            const balance = balances[i];
-            const currencyId = this.safeString(balance, 'asset');
+            const entry = balances[i];
+            const currencyId = this.safeString(entry, 'ccy');
             const code = this.safeCurrencyCode(currencyId);
             const account = this.account();
-            account['free'] = this.safeString(balance, 'available');
-            const frozen = this.safeString(balance, 'frozen');
-            const locked = this.safeString(balance, 'lock');
-            account['used'] = Precise["default"].stringAdd(frozen, locked);
+            account['free'] = this.safeString(entry, 'available');
+            account['used'] = this.safeString(entry, 'frozen');
             result[code] = account;
         }
         return this.safeBalance(result);
@@ -1722,10 +1676,10 @@ class coinex extends coinex$1 {
          * @method
          * @name coinex#fetchBalance
          * @description query for balance and get the amount of funds available for trading or funds locked in orders
-         * @see https://viabtc.github.io/coinex_api_en_doc/spot/#docsspot002_account001_account_info         // spot
-         * @see https://viabtc.github.io/coinex_api_en_doc/spot/#docsspot002_account004_investment_balance   // financial
-         * @see https://viabtc.github.io/coinex_api_en_doc/spot/#docsspot002_account006_margin_account       // margin
-         * @see https://viabtc.github.io/coinex_api_en_doc/futures/#docsfutures001_http016_asset_query       // swap
+         * @see https://docs.coinex.com/api/v2/assets/balance/http/get-spot-balance         // spot
+         * @see https://docs.coinex.com/api/v2/assets/balance/http/get-futures-balance      // swap
+         * @see https://docs.coinex.com/api/v2/assets/balance/http/get-marigin-balance      // margin
+         * @see https://docs.coinex.com/api/v2/assets/balance/http/get-financial-balance    // financial
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @param {string} [params.type] 'margin', 'swap', 'financial', or 'spot'
          * @returns {object} a [balance structure]{@link https://docs.ccxt.com/#/?id=balance-structure}
@@ -5821,7 +5775,11 @@ class coinex extends coinex$1 {
                 this.checkRequiredCredentials();
                 query = this.keysort(query);
                 const urlencoded = this.rawencode(query);
-                const preparedString = method + '/' + version + '/' + path + '?' + urlencoded + nonce + this.secret;
+                let preparedString = method + '/' + version + '/' + path;
+                if (urlencoded) {
+                    preparedString += '?' + urlencoded;
+                }
+                preparedString += nonce + this.secret;
                 const signature = this.hash(this.encode(preparedString), sha256.sha256);
                 headers = {
                     'X-COINEX-KEY': this.apiKey,
@@ -5829,7 +5787,9 @@ class coinex extends coinex$1 {
                     'X-COINEX-TIMESTAMP': nonce,
                 };
                 if ((method === 'GET') || (method === 'DELETE') || (method === 'PUT')) {
-                    url += '?' + urlencoded;
+                    if (urlencoded) {
+                        url += '?' + urlencoded;
+                    }
                 }
                 else {
                     body = this.json(query);

package/dist/cjs/src/okx.js

@@ -7925,7 +7925,7 @@ class okx extends okx$1 {
         //     }
         //
         const rows = this.safeList(response, 'data', []);
-        return this.parseConversions(rows, 'baseCcy', 'quoteCcy', since, limit);
+        return this.parseConversions(rows, code, 'baseCcy', 'quoteCcy', since, limit);
     }
     parseConversion(conversion, fromCurrency = undefined, toCurrency = undefined) {
         //

package/dist/cjs/src/woo.js

@@ -3182,7 +3182,7 @@ class woo extends woo$1 {
         //
         const data = this.safeDict(response, 'data', {});
         const rows = this.safeList(data, 'tradeVos', []);
-        return this.parseConversions(rows, 'sellAsset', 'buyAsset', since, limit);
+        return this.parseConversions(rows, code, 'sellAsset', 'buyAsset', since, limit);
     }
     parseConversion(conversion, fromCurrency = undefined, toCurrency = undefined) {
         //

package/js/ccxt.d.ts

@@ -4,7 +4,7 @@ import * as functions from './src/base/functions.js';
 import * as errors from './src/base/errors.js';
 import type { Market, Trade, Fee, Ticker, OrderBook, Order, Transaction, Tickers, Currency, Balance, DepositAddress, WithdrawalResponse, DepositAddressResponse, OHLCV, Balances, PartialBalances, Dictionary, MinMax, Position, FundingRateHistory, Liquidation, FundingHistory, MarginMode, Greeks, Leverage, Leverages, Option, OptionChain, Conversion } from './src/base/types.js';
 import { BaseError, ExchangeError, AuthenticationError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, OperationRejected, NoChange, MarginModeAlreadySet, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, AddressPending, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, ContractUnavailable, NotSupported, ProxyError, ExchangeClosedByUser, OperationFailed, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout } from './src/base/errors.js';
-declare const version = "4.3.6";
+declare const version = "4.3.7";
 import ace from './src/ace.js';
 import alpaca from './src/alpaca.js';
 import ascendex from './src/ascendex.js';

package/js/ccxt.js

@@ -38,7 +38,7 @@ import * as errors from './src/base/errors.js';
 import { BaseError, ExchangeError, AuthenticationError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, OperationRejected, NoChange, MarginModeAlreadySet, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, AddressPending, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, ContractUnavailable, NotSupported, ProxyError, ExchangeClosedByUser, OperationFailed, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout } from './src/base/errors.js';
 //-----------------------------------------------------------------------------
 // this is updated by vss.js when building
-const version = '4.3.7';
+const version = '4.3.8';
 Exchange.ccxtVersion = version;
 //-----------------------------------------------------------------------------
 import ace from './src/ace.js';

package/js/src/base/Exchange.d.ts

@@ -166,21 +166,21 @@ export default class Exchange {
     newUpdates: boolean;
     streaming: {};
     alias: boolean;
-    deepExtend: (...xs: any[]) => any;
+    deepExtend: (...xs: any) => any;
     isNode: boolean;
     keys: {
         (o: object): string[];
         (o: {}): string[];
     };
-    values: (x: any) => any[];
+    values: (x: any[] | Dictionary<any>) => any[];
     extend: (...args: any[]) => any;
     clone: (x: any) => any;
-    flatten: (x: any, out?: any[]) => any[];
-    unique: (x: any) => any[];
-    indexBy: (x: any, k: any, out?: {}) => {};
-    sortBy: (array: any, key: any, descending?: boolean, defaultValue?: any, direction?: number) => any;
-    sortBy2: (array: any, key1: any, key2: any, descending?: boolean, direction?: number) => any;
-    groupBy: (x: any, k: any, out?: {}) => {};
+    flatten: (x: any[], out?: any[]) => any[];
+    unique: (x: any[]) => any[];
+    indexBy: (x: Dictionary<any>, k: IndexType, out?: Dictionary<any>) => Dictionary<any>;
+    sortBy: (array: any[], key: IndexType, descending?: boolean, defaultValue?: any, direction?: number) => any[];
+    sortBy2: (array: any[], key1: IndexType, key2: IndexType, descending?: boolean, direction?: number) => any[];
+    groupBy: (x: Dictionary<any>, k: string, out?: Dictionary<any>) => Dictionary<any>;
     aggregate: typeof functions.aggregate;
     uuid: (a?: any) => string;
     unCamelCase: (s: string) => string;
@@ -200,7 +200,7 @@ export default class Exchange {
     numberToBE: (n: number, padding: number) => Uint8Array;
     base16ToBinary: (str: string) => Uint8Array;
     iso8601: (timestamp: any) => string;
-    omit: (x: any, ...args: any[]) => any;
+    omit: (x: Dictionary<any>, ...args: any[]) => any;
     isJsonEncodedObject: (object: any) => boolean;
     safeInteger: (o: any, k: IndexType, $default?: number) => number;
     sum: (...xs: any[]) => any;
@@ -209,7 +209,7 @@ export default class Exchange {
     extractParams: (string: any) => any[];
     json: (data: any, params?: any) => string;
     vwap: typeof functions.vwap;
-    merge: (target: any, ...args: any[]) => any;
+    merge: (target: Dictionary<any>, ...args: any) => Dictionary<any>;
     binaryConcat: typeof import("../static_dependencies/noble-curves/abstract/utils.js").concatBytes;
     hash: (request: import("../static_dependencies/noble-hashes/utils.js").Input, hash: {
         (message: import("../static_dependencies/noble-hashes/utils.js").Input): Uint8Array;
@@ -217,7 +217,7 @@ export default class Exchange {
         blockLen: number;
         create(): import("../static_dependencies/noble-hashes/utils.js").Hash<import("../static_dependencies/noble-hashes/utils.js").Hash<any>>;
     }, digest?: "binary" | "hex" | "base64") => any;
-    arrayConcat: (a: any, b: any) => any;
+    arrayConcat: (a: any[], b: any[]) => any[];
     encode: (str: string) => Uint8Array;
     urlencode: (object: object) => string;
     hmac: (request: import("../static_dependencies/noble-hashes/utils.js").Input, secret: import("../static_dependencies/noble-hashes/utils.js").Input, hash: {
@@ -249,19 +249,19 @@ export default class Exchange {
     base64ToBinary: (str: string) => Uint8Array;
     safeTimestamp2: (o: any, k1: IndexType, k2: IndexType, $default?: any) => number;
     rawencode: (object: object) => string;
-    keysort: (x: any, out?: {}) => {};
-    inArray: (needle: any, haystack: any) => any;
+    keysort: (x: Dictionary<any>, out?: Dictionary<any>) => Dictionary<any>;
+    inArray: (needle: any, haystack: any[]) => boolean;
     safeStringLower2: (o: any, k1: IndexType, k2: IndexType, $default?: string) => string;
     safeStringUpper2: (o: any, k1: IndexType, k2: IndexType, $default?: string) => string;
-    isEmpty: (object: any) => boolean;
-    ordered: (x: any) => any;
-    filterBy: (x: any, k: any, value?: any, out?: any[]) => any[];
+    isEmpty: (object: any[] | Dictionary<any>) => boolean;
+    ordered: (x: any[] | Dictionary<any>) => any[] | Dictionary<any>;
+    filterBy: (x: Dictionary<any>, k: string, value?: any, out?: Dictionary<any>[]) => Dictionary<any>[];
     uuid16: (a?: any) => string;
     urlencodeWithArrayRepeat: (object: object) => string;
     microseconds: () => number;
     binaryToBase64: (data: Uint8Array) => string;
     strip: (s: string) => string;
-    toArray: (object: any) => unknown[];
+    toArray: (object: any[] | Dictionary<any>) => any[];
     safeFloatN: (o: any, k: IndexType[], $default?: number) => number;
     safeIntegerN: (o: any, k: IndexType[], $default?: number) => number;
     safeIntegerProductN: (o: any, k: IndexType[], $factor: number, $default?: number) => number;
@@ -1017,7 +1017,7 @@ export default class Exchange {
     filterBySymbolsSinceLimit(array: any, symbols?: string[], since?: Int, limit?: Int, tail?: boolean): any;
     parseLastPrices(pricesData: any, symbols?: string[], params?: {}): LastPrices;
     parseTickers(tickers: any, symbols?: string[], params?: {}): Dictionary<Ticker>;
-    parseDepositAddresses(addresses: any, codes?: string[], indexed?: boolean, params?: {}): {};
+    parseDepositAddresses(addresses: any, codes?: string[], indexed?: boolean, params?: {}): Dictionary<any>;
     parseBorrowInterests(response: any, market?: Market): any[];
     parseFundingRateHistories(response: any, market?: any, since?: Int, limit?: Int): FundingRateHistory[];
     safeSymbol(marketId: Str, market?: Market, delimiter?: Str, marketType?: Str): string;
@@ -1072,7 +1072,7 @@ export default class Exchange {
     parseMarginMode(marginMode: any, market?: Market): MarginMode;
     parseLeverages(response: object[], symbols?: string[], symbolKey?: Str, marketType?: MarketType): Leverages;
     parseLeverage(leverage: any, market?: Market): Leverage;
-    parseConversions(conversions: any[], fromCurrencyKey?: Str, toCurrencyKey?: Str, since?: Int, limit?: Int, params?: {}): Conversion[];
+    parseConversions(conversions: any[], code?: Str, fromCurrencyKey?: Str, toCurrencyKey?: Str, since?: Int, limit?: Int, params?: {}): Conversion[];
     parseConversion(conversion: any, fromCurrency?: Currency, toCurrency?: Currency): Conversion;
     convertExpireDate(date: string): string;
     convertExpireDateToMarketIdDate(date: string): string;

package/js/src/base/Exchange.js

@@ -6091,7 +6091,7 @@ export default class Exchange {
     parseLeverage(leverage, market = undefined) {
         throw new NotSupported(this.id + ' parseLeverage () is not supported yet');
     }
-    parseConversions(conversions, fromCurrencyKey = undefined, toCurrencyKey = undefined, since = undefined, limit = undefined, params = {}) {
+    parseConversions(conversions, code = undefined, fromCurrencyKey = undefined, toCurrencyKey = undefined, since = undefined, limit = undefined, params = {}) {
         conversions = this.toArray(conversions);
         const result = [];
         let fromCurrency = undefined;
@@ -6110,8 +6110,18 @@ export default class Exchange {
             result.push(conversion);
         }
         const sorted = this.sortBy(result, 'timestamp');
-        const code = (fromCurrency !== undefined) ? fromCurrency['code'] : undefined;
-        return this.filterByCurrencySinceLimit(sorted, code, since, limit);
+        let currency = undefined;
+        if (code !== undefined) {
+            currency = this.currency(code);
+            code = currency['code'];
+        }
+        if (code === undefined) {
+            return this.filterBySinceLimit(sorted, since, limit);
+        }
+        const fromConversion = this.filterBy(sorted, 'fromCurrency', code);
+        const toConversion = this.filterBy(sorted, 'toCurrency', code);
+        const both = this.arrayConcat(fromConversion, toConversion);
+        return this.filterBySinceLimit(both, since, limit);
     }
     parseConversion(conversion, fromCurrency = undefined, toCurrency = undefined) {
         throw new NotSupported(this.id + ' parseConversion () is not supported yet');