ccxt 4.3.7 → 4.3.8

package/js/src/base/functions/generic.d.ts

@@ -1,27 +1,28 @@
+import { Dictionary, IndexType } from '../types.js';
 declare const keys: {
     (o: object): string[];
     (o: {}): string[];
 };
-declare const values: (x: any) => any[];
-declare const index: (x: any) => Set<any>;
+declare const values: (x: any[] | Dictionary<any>) => any[];
+declare const index: (x: any[]) => Set<any>;
 declare const extend: (...args: any[]) => any;
 declare const clone: (x: any) => any;
-declare const ordered: (x: any) => any;
-declare const unique: (x: any) => any[];
-declare const arrayConcat: (a: any, b: any) => any;
-declare const inArray: (needle: any, haystack: any) => any;
-declare const toArray: (object: any) => unknown[];
-declare const isEmpty: (object: any) => boolean;
-declare const keysort: (x: any, out?: {}) => {};
-declare const groupBy: (x: any, k: any, out?: {}) => {};
-declare const indexBy: (x: any, k: any, out?: {}) => {};
-declare const filterBy: (x: any, k: any, value?: any, out?: any[]) => any[];
-declare const sortBy: (array: any, key: any, descending?: boolean, defaultValue?: any, direction?: number) => any;
-declare const sortBy2: (array: any, key1: any, key2: any, descending?: boolean, direction?: number) => any;
-declare const flatten: (x: any, out?: any[]) => any[];
-declare const pluck: (x: any, k: any) => any[];
-declare const omit: (x: any, ...args: any[]) => any;
+declare const ordered: (x: any[] | Dictionary<any>) => any[] | Dictionary<any>;
+declare const unique: (x: any[]) => any[];
+declare const arrayConcat: (a: any[], b: any[]) => any[];
+declare const inArray: (needle: any, haystack: any[]) => boolean;
+declare const toArray: (object: Dictionary<any> | any[]) => any[];
+declare const isEmpty: (object: any[] | Dictionary<any>) => boolean;
+declare const keysort: (x: Dictionary<any>, out?: Dictionary<any>) => Dictionary<any>;
+declare const groupBy: (x: Dictionary<any>, k: string, out?: Dictionary<any>) => Dictionary<any>;
+declare const indexBy: (x: Dictionary<any>, k: IndexType, out?: Dictionary<any>) => Dictionary<any>;
+declare const filterBy: (x: Dictionary<any>, k: string, value?: any, out?: Dictionary<any>[]) => Dictionary<any>[];
+declare const sortBy: (array: any[], key: IndexType, descending?: boolean, defaultValue?: any, direction?: number) => any[];
+declare const sortBy2: (array: any[], key1: IndexType, key2: IndexType, descending?: boolean, direction?: number) => any[];
+declare const flatten: (x: any[], out?: any[]) => any[];
+declare const pluck: (x: Dictionary<any>, k: any) => any[];
+declare const omit: (x: Dictionary<any>, ...args: any[]) => any;
 declare const sum: (...xs: any[]) => any;
-declare const deepExtend: (...xs: any[]) => any;
-declare const merge: (target: any, ...args: any[]) => any;
+declare const deepExtend: (...xs: any) => any;
+declare const merge: (target: Dictionary<any>, ...args: any) => Dictionary<any>;
 export { keys, values, extend, clone, index, ordered, unique, arrayConcat, inArray, toArray, isEmpty, keysort, indexBy, groupBy, filterBy, sortBy, sortBy2, flatten, pluck, omit, sum, deepExtend, merge, };

package/js/src/binance.js

@@ -12922,7 +12922,7 @@ export default class binance extends Exchange {
             //
         }
         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/js/src/bingx.d.ts

@@ -97,7 +97,7 @@ export default class bingx extends Exchange {
         toAccount: string;
         status: string;
     };
-    fetchDepositAddressesByNetwork(code: string, params?: {}): Promise<{}>;
+    fetchDepositAddressesByNetwork(code: string, params?: {}): Promise<import("./base/types.js").Dictionary<any>>;
     fetchDepositAddress(code: string, params?: {}): Promise<import("./base/types.js").Dictionary<any>>;
     parseDepositAddress(depositAddress: any, currency?: Currency): {
         currency: string;
@@ -133,7 +133,7 @@ export default class bingx extends Exchange {
     };
     fetchDepositWithdrawFees(codes?: Strings, params?: {}): Promise<any>;
     withdraw(code: string, amount: number, address: string, tag?: any, params?: {}): Promise<Transaction>;
-    parseParams(params: any): {};
+    parseParams(params: any): import("./base/types.js").Dictionary<any>;
     fetchMyLiquidations(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<import("./base/types.js").Liquidation[]>;
     parseLiquidation(liquidation: any, market?: Market): import("./base/types.js").Liquidation;
     closePosition(symbol: string, side?: OrderSide, params?: {}): Promise<Order>;

package/js/src/bingx.js

@@ -2466,7 +2466,7 @@ export default class bingx extends Exchange {
         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/js/src/bitget.js

@@ -8675,7 +8675,7 @@ export default class bitget extends Exchange {
         //
         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/js/src/bybit.d.ts

@@ -91,7 +91,7 @@ export default class bybit extends Exchange {
         network: string;
         info: any;
     };
-    fetchDepositAddressesByNetwork(code: string, params?: {}): Promise<{}>;
+    fetchDepositAddressesByNetwork(code: string, params?: {}): Promise<import("./base/types.js").Dictionary<any>>;
     fetchDepositAddress(code: string, params?: {}): Promise<{
         currency: string;
         address: string;

package/js/src/coinbase.d.ts

@@ -94,7 +94,7 @@ export default class coinbase extends Exchange {
     fetchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     fetchBidsAsks(symbols?: Strings, params?: {}): Promise<import("./base/types.js").Dictionary<Ticker>>;
     withdraw(code: string, amount: number, address: string, tag?: any, params?: {}): Promise<Transaction>;
-    fetchDepositAddressesByNetwork(code: string, params?: {}): Promise<{}>;
+    fetchDepositAddressesByNetwork(code: string, params?: {}): Promise<import("./base/types.js").Dictionary<any>>;
     parseDepositAddress(depositAddress: any, currency?: Currency): {
         info: any;
         currency: string;

package/js/src/coinbaseinternational.d.ts

@@ -42,7 +42,7 @@ export default class coinbaseinternational extends Exchange {
         address: string;
         info: any;
     }>;
-    findDefaultNetwork(networks: any): unknown;
+    findDefaultNetwork(networks: any): any;
     loadCurrencyNetworks(code: any, params?: {}): Promise<void>;
     parseNetworks(networks: any, params?: {}): {};
     parseNetwork(network: any, params?: {}): {

package/js/src/coinex.js

@@ -1532,190 +1532,144 @@ export default class coinex extends Exchange {
     }
     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 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.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.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.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.stringAdd(frozen, locked);
+            account['free'] = this.safeString(entry, 'available');
+            account['used'] = this.safeString(entry, 'frozen');
             result[code] = account;
         }
         return this.safeBalance(result);
@@ -1725,10 +1679,10 @@ export default class coinex extends Exchange {
          * @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}
@@ -5824,7 +5778,11 @@ export default class coinex extends Exchange {
                 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);
                 headers = {
                     'X-COINEX-KEY': this.apiKey,
@@ -5832,7 +5790,9 @@ export default class coinex extends Exchange {
                     'X-COINEX-TIMESTAMP': nonce,
                 };
                 if ((method === 'GET') || (method === 'DELETE') || (method === 'PUT')) {
-                    url += '?' + urlencoded;
+                    if (urlencoded) {
+                        url += '?' + urlencoded;
+                    }
                 }
                 else {
                     body = this.json(query);

package/js/src/gemini.d.ts

@@ -45,7 +45,7 @@ export default class gemini extends Exchange {
         info: any;
     };
     fetchDepositAddress(code: string, params?: {}): Promise<any>;
-    fetchDepositAddressesByNetwork(code: string, params?: {}): Promise<{}>;
+    fetchDepositAddressesByNetwork(code: string, params?: {}): Promise<import("./base/types.js").Dictionary<any>>;
     sign(path: any, api?: string, method?: string, params?: {}, headers?: any, body?: any): {
         url: string;
         method: string;

package/js/src/hollaex.d.ts

@@ -39,7 +39,7 @@ export default class hollaex extends Exchange {
         network: string;
         info: any;
     };
-    fetchDepositAddresses(codes?: string[], params?: {}): Promise<{}>;
+    fetchDepositAddresses(codes?: string[], params?: {}): Promise<Dictionary<any>>;
     fetchDeposits(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
     fetchWithdrawal(id: string, code?: Str, params?: {}): Promise<Transaction>;
     fetchWithdrawals(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;

package/js/src/htx.d.ts

@@ -101,7 +101,7 @@ export default class htx extends Exchange {
         note: string;
         info: any;
     };
-    fetchDepositAddressesByNetwork(code: string, params?: {}): Promise<{}>;
+    fetchDepositAddressesByNetwork(code: string, params?: {}): Promise<import("./base/types.js").Dictionary<any>>;
     fetchDepositAddress(code: string, params?: {}): Promise<any>;
     fetchWithdrawAddresses(code: string, note?: any, networkCode?: any, params?: {}): Promise<any[]>;
     fetchDeposits(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
@@ -245,7 +245,7 @@ export default class htx extends Exchange {
         datetime: string;
         info: any;
     };
-    fetchSettlementHistory(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    fetchSettlementHistory(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any[]>;
     fetchDepositWithdrawFees(codes?: Strings, params?: {}): Promise<any>;
     parseDepositWithdrawFee(fee: any, currency?: Currency): any;
     parseSettlements(settlements: any, market: any): any[];

package/js/src/idex.d.ts

@@ -17,7 +17,7 @@ export default class idex extends Exchange {
     parseTrade(trade: any, market?: Market): Trade;
     fetchTradingFees(params?: {}): Promise<TradingFees>;
     fetchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
-    parseSide(book: any, side: any): any;
+    parseSide(book: any, side: any): any[];
     fetchCurrencies(params?: {}): Promise<Currencies>;
     parseBalance(response: any): Balances;
     fetchBalance(params?: {}): Promise<Balances>;

package/js/src/kucoin.d.ts

@@ -63,7 +63,7 @@ export default class kucoin extends Exchange {
         tag: string;
         network: string;
     };
-    fetchDepositAddressesByNetwork(code: string, params?: {}): Promise<{}>;
+    fetchDepositAddressesByNetwork(code: string, params?: {}): Promise<import("./base/types.js").Dictionary<any>>;
     fetchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     handleTriggerPrices(params: any): any[];
     createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;

package/js/src/mexc.d.ts

@@ -111,7 +111,7 @@ export default class mexc extends Exchange {
         network: string;
         info: any;
     };
-    fetchDepositAddressesByNetwork(code: string, params?: {}): Promise<{}>;
+    fetchDepositAddressesByNetwork(code: string, params?: {}): Promise<import("./base/types.js").Dictionary<any>>;
     createDepositAddress(code: string, params?: {}): Promise<{
         currency: string;
         address: string;

package/js/src/okcoin.d.ts

@@ -42,7 +42,7 @@ export default class okcoin extends Exchange {
         info: any;
     };
     fetchDepositAddress(code: string, params?: {}): Promise<any>;
-    fetchDepositAddressesByNetwork(code: string, params?: {}): Promise<{}>;
+    fetchDepositAddressesByNetwork(code: string, params?: {}): Promise<import("./base/types.js").Dictionary<any>>;
     transfer(code: string, amount: number, fromAccount: string, toAccount: string, params?: {}): Promise<TransferEntry>;
     parseTransfer(transfer: any, currency?: Currency): {
         info: any;

package/js/src/okx.d.ts

@@ -85,7 +85,7 @@ export default class okx extends Exchange {
         network: string;
         info: any;
     };
-    fetchDepositAddressesByNetwork(code: string, params?: {}): Promise<{}>;
+    fetchDepositAddressesByNetwork(code: string, params?: {}): Promise<import("./base/types.js").Dictionary<any>>;
     fetchDepositAddress(code: string, params?: {}): Promise<any>;
     withdraw(code: string, amount: number, address: string, tag?: any, params?: {}): Promise<Transaction>;
     fetchDeposits(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;

package/js/src/okx.js

@@ -7928,7 +7928,7 @@ export default class okx extends Exchange {
         //     }
         //
         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/js/src/paymium.d.ts

@@ -27,7 +27,7 @@ export default class paymium extends Exchange {
         tag: any;
         network: any;
     }>;
-    fetchDepositAddresses(codes?: string[], params?: {}): Promise<{}>;
+    fetchDepositAddresses(codes?: string[], params?: {}): Promise<import("./base/types.js").Dictionary<any>>;
     parseDepositAddress(depositAddress: any, currency?: Currency): {
         info: any;
         currency: string;

package/js/src/pro/luno.d.ts

@@ -10,8 +10,8 @@ export default class luno extends lunoRest {
     handleOrderBook(client: Client, message: any, subscription: any): void;
     customParseOrderBook(orderbook: any, symbol: any, timestamp?: any, bidsKey?: string, asksKey?: IndexType, priceKey?: IndexType, amountKey?: IndexType, countOrIdKey?: IndexType): {
         symbol: any;
-        bids: any;
-        asks: any;
+        bids: any[];
+        asks: any[];
         timestamp: any;
         datetime: string;
         nonce: any;

package/js/src/probit.d.ts

@@ -44,7 +44,7 @@ export default class probit extends Exchange {
         network: string;
         info: any;
     }>;
-    fetchDepositAddresses(codes?: string[], params?: {}): Promise<{}>;
+    fetchDepositAddresses(codes?: string[], params?: {}): Promise<import("./base/types.js").Dictionary<any>>;
     withdraw(code: string, amount: number, address: string, tag?: any, params?: {}): Promise<Transaction>;
     fetchDeposits(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
     fetchWithdrawals(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;

package/js/src/upbit.d.ts

@@ -67,7 +67,7 @@ export default class upbit extends Exchange {
     fetchClosedOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchCanceledOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
-    fetchDepositAddresses(codes?: string[], params?: {}): Promise<{}>;
+    fetchDepositAddresses(codes?: string[], params?: {}): Promise<Dictionary<any>>;
     parseDepositAddress(depositAddress: any, currency?: Currency): {
         currency: string;
         address: string;

package/js/src/whitebit.d.ts

@@ -103,7 +103,7 @@ export default class whitebit extends Exchange {
         previousFundingTimestamp: any;
         previousFundingDatetime: any;
     };
-    isFiat(currency: any): any;
+    isFiat(currency: any): boolean;
     nonce(): number;
     sign(path: any, api?: string, method?: string, params?: {}, headers?: any, body?: any): {
         url: string;