ccxt 4.2.31 → 4.2.34

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

@@ -410,7 +410,7 @@ class woo extends woo$1 {
         }
         return true;
     }
-    authenticate(params = {}) {
+    async authenticate(params = {}) {
         this.checkRequiredCredentials();
         const url = this.urls['api']['ws']['private'] + '/' + this.uid;
         const client = this.client(url);
@@ -816,13 +816,15 @@ class woo extends woo$1 {
         const event = this.safeString(message, 'event');
         let method = this.safeValue(methods, event);
         if (method !== undefined) {
-            return method.call(this, client, message);
+            method.call(this, client, message);
+            return;
         }
         const topic = this.safeString(message, 'topic');
         if (topic !== undefined) {
             method = this.safeValue(methods, topic);
             if (method !== undefined) {
-                return method.call(this, client, message);
+                method.call(this, client, message);
+                return;
             }
             const splitTopic = topic.split('@');
             const splitLength = splitTopic.length;
@@ -830,19 +832,19 @@ class woo extends woo$1 {
                 const name = this.safeString(splitTopic, 1);
                 method = this.safeValue(methods, name);
                 if (method !== undefined) {
-                    return method.call(this, client, message);
+                    method.call(this, client, message);
+                    return;
                 }
                 const splitName = name.split('_');
                 const splitNameLength = splitTopic.length;
                 if (splitNameLength === 2) {
                     method = this.safeValue(methods, this.safeString(splitName, 0));
                     if (method !== undefined) {
-                        return method.call(this, client, message);
+                        method.call(this, client, message);
                     }
                 }
             }
         }
-        return message;
     }
     ping(client) {
         return { 'event': 'ping' };

package/dist/cjs/src/probit.js

@@ -422,8 +422,8 @@ class probit extends probit$1 {
             const networkList = {};
             for (let j = 0; j < platformsByPriority.length; j++) {
                 const network = platformsByPriority[j];
-                const networkId = this.safeString(network, 'id');
-                const networkCode = this.networkIdToCode(networkId);
+                const idInner = this.safeString(network, 'id');
+                const networkCode = this.networkIdToCode(idInner);
                 const currentDepositSuspended = this.safeValue(network, 'deposit_suspended');
                 const currentWithdrawalSuspended = this.safeValue(network, 'withdrawal_suspended');
                 const currentDeposit = !currentDepositSuspended;
@@ -444,7 +444,7 @@ class probit extends probit$1 {
                     }
                 }
                 networkList[networkCode] = {
-                    'id': networkId,
+                    'id': idInner,
                     'network': networkCode,
                     'active': currentActive,
                     'deposit': currentDeposit,

package/dist/cjs/src/tokocrypto.js

@@ -1362,9 +1362,9 @@ class tokocrypto extends tokocrypto$1 {
         //         "timestamp":1659666786943
         //     }
         //
-        return this.parseBalance(response, type, marginMode);
+        return this.parseBalanceCustom(response, type, marginMode);
     }
-    parseBalance(response, type = undefined, marginMode = undefined) {
+    parseBalanceCustom(response, type = undefined, marginMode = undefined) {
         const timestamp = this.safeInteger(response, 'updateTime');
         const result = {
             'info': response,

package/dist/cjs/src/wavesexchange.js

@@ -1253,7 +1253,8 @@ class wavesexchange extends wavesexchange$1 {
         // precise.decimals should be integer
         precise.decimals = this.parseToInt(Precise["default"].stringSub(this.numberToString(precise.decimals), this.numberToString(scale)));
         precise.reduce();
-        return precise;
+        const stringValue = precise.toString();
+        return stringValue;
     }
     currencyFromPrecision(currency, amount) {
         const scale = this.currencies[currency]['precision'];

package/dist/cjs/src/woo.js

@@ -856,7 +856,7 @@ class woo extends woo$1 {
         const stopLoss = this.safeValue(params, 'stopLoss');
         const takeProfit = this.safeValue(params, 'takeProfit');
         const algoType = this.safeString(params, 'algoType');
-        const trailingTriggerPrice = this.safeString2(params, 'trailingTriggerPrice', 'activatedPrice', price);
+        const trailingTriggerPrice = this.safeString2(params, 'trailingTriggerPrice', 'activatedPrice', this.numberToString(price));
         const trailingAmount = this.safeString2(params, 'trailingAmount', 'callbackValue');
         const trailingPercent = this.safeString2(params, 'trailingPercent', 'callbackRate');
         const isTrailingAmountOrder = trailingAmount !== undefined;

package/dist/cjs/src/yobit.js

@@ -1177,11 +1177,29 @@ class yobit extends yobit$1 {
         const address = this.safeString(response['return'], 'address');
         this.checkAddress(address);
         return {
+            'id': undefined,
             'currency': code,
             'address': address,
             'tag': undefined,
             'network': undefined,
             'info': response,
+            'txid': undefined,
+            'type': undefined,
+            'amount': undefined,
+            'status': undefined,
+            'timestamp': undefined,
+            'datetime': undefined,
+            'addressFrom': undefined,
+            'addressTo': undefined,
+            'tagFrom': undefined,
+            'tagTo': undefined,
+            'updated': undefined,
+            'comment': undefined,
+            'fee': {
+                'currency': undefined,
+                'cost': undefined,
+                'rate': undefined,
+            },
         };
     }
     async withdraw(code, amount, address, tag = undefined, params = {}) {
@@ -1214,6 +1232,27 @@ class yobit extends yobit$1 {
         return {
             'info': response,
             'id': undefined,
+            'txid': undefined,
+            'type': undefined,
+            'currency': undefined,
+            'network': undefined,
+            'amount': undefined,
+            'status': undefined,
+            'timestamp': undefined,
+            'datetime': undefined,
+            'address': undefined,
+            'addressFrom': undefined,
+            'addressTo': undefined,
+            'tag': undefined,
+            'tagFrom': undefined,
+            'tagTo': undefined,
+            'updated': undefined,
+            'comment': undefined,
+            'fee': {
+                'currency': undefined,
+                'cost': undefined,
+                'rate': undefined,
+            },
         };
     }
     sign(path, api = 'public', method = 'GET', params = {}, headers = undefined, body = 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 } from './src/base/types.js';
 import { BaseError, ExchangeError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, MarginModeAlreadySet, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, NotSupported, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout, AuthenticationError, AddressPending, NoChange } from './src/base/errors.js';
-declare const version = "4.2.30";
+declare const version = "4.2.33";
 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, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, MarginModeAlreadySet, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, NotSupported, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout, AuthenticationError, AddressPending, NoChange } from './src/base/errors.js';
 //-----------------------------------------------------------------------------
 // this is updated by vss.js when building
-const version = '4.2.31';
+const version = '4.2.34';
 Exchange.ccxtVersion = version;
 //-----------------------------------------------------------------------------
 import ace from './src/ace.js';

package/js/src/ace.d.ts

@@ -16,7 +16,7 @@ export default class ace extends Exchange {
     fetchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     parseOrderStatus(status: any): string;
     parseOrder(order: any, market?: Market): Order;
-    createOrder(symbol: string, type: OrderType, side: OrderSide, amount: any, price?: any, params?: {}): Promise<Order>;
+    createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, params?: {}): Promise<Order>;
     cancelOrder(id: string, symbol?: Str, params?: {}): Promise<any>;
     fetchOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
     fetchOpenOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;

package/js/src/ace.js

@@ -1051,8 +1051,9 @@ export default class ace extends Exchange {
         const feedback = this.id + ' ' + body;
         const status = this.safeNumber(response, 'status', 200);
         if (status > 200) {
-            this.throwExactlyMatchedException(this.exceptions['exact'], status, feedback);
-            this.throwBroadlyMatchedException(this.exceptions['broad'], status, feedback);
+            const statusStr = status.toString();
+            this.throwExactlyMatchedException(this.exceptions['exact'], statusStr, feedback);
+            this.throwBroadlyMatchedException(this.exceptions['broad'], statusStr, feedback);
         }
         return undefined;
     }

package/js/src/alpaca.d.ts

@@ -13,7 +13,7 @@ export default class alpaca extends Exchange {
     fetchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     fetchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     parseOHLCV(ohlcv: any, market?: Market): OHLCV;
-    createOrder(symbol: string, type: OrderType, side: OrderSide, amount: any, price?: any, params?: {}): Promise<Order>;
+    createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, params?: {}): Promise<Order>;
     cancelOrder(id: string, symbol?: Str, params?: {}): Promise<any>;
     cancelAllOrders(symbol?: Str, params?: {}): Promise<any>;
     fetchOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;

package/js/src/ascendex.d.ts

@@ -1,5 +1,5 @@
 import Exchange from './abstract/ascendex.js';
-import type { FundingHistory, Int, OHLCV, Order, OrderSide, OrderType, OrderRequest, Str, Trade, Balances, Transaction, Ticker, OrderBook, Tickers, Strings, Currency, Market } from './base/types.js';
+import type { TransferEntry, FundingHistory, Int, OHLCV, Order, OrderSide, OrderType, OrderRequest, Str, Trade, Balances, Transaction, Ticker, OrderBook, Tickers, Strings, Currency, Market } from './base/types.js';
 /**
  * @class ascendex
  * @augments Exchange
@@ -31,8 +31,8 @@ export default class ascendex extends Exchange {
     parseOrderStatus(status: any): string;
     parseOrder(order: any, market?: Market): Order;
     fetchTradingFees(params?: {}): Promise<{}>;
-    createOrderRequest(symbol: string, type: OrderType, side: OrderSide, amount: any, price?: any, params?: {}): any;
-    createOrder(symbol: string, type: OrderType, side: OrderSide, amount: any, price?: any, params?: {}): Promise<Order>;
+    createOrderRequest(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, params?: {}): any;
+    createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, params?: {}): Promise<Order>;
     createOrders(orders: OrderRequest[], params?: {}): Promise<Order[]>;
     fetchOrder(id: string, symbol?: Str, params?: {}): Promise<Order>;
     fetchOpenOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
@@ -86,7 +86,7 @@ export default class ascendex extends Exchange {
     };
     reduceMargin(symbol: string, amount: any, params?: {}): Promise<any>;
     addMargin(symbol: string, amount: any, params?: {}): Promise<any>;
-    setLeverage(leverage: any, symbol?: Str, params?: {}): Promise<any>;
+    setLeverage(leverage: Int, symbol?: Str, params?: {}): Promise<any>;
     setMarginMode(marginMode: any, symbol?: Str, params?: {}): Promise<any>;
     fetchLeverageTiers(symbols?: Strings, params?: {}): Promise<{}>;
     parseMarketLeverageTiers(info: any, market?: Market): any[];
@@ -103,17 +103,7 @@ export default class ascendex extends Exchange {
         networks: {};
     };
     fetchDepositWithdrawFees(codes?: Strings, params?: {}): Promise<any>;
-    transfer(code: string, amount: any, fromAccount: any, toAccount: any, params?: {}): Promise<{
-        info: any;
-        id: any;
-        timestamp: number;
-        datetime: string;
-        currency: string;
-        amount: any;
-        fromAccount: any;
-        toAccount: any;
-        status: string;
-    }>;
+    transfer(code: string, amount: number, fromAccount: any, toAccount: any, params?: {}): Promise<TransferEntry>;
     parseTransfer(transfer: any, currency?: Currency): {
         info: any;
         id: any;

package/js/src/ascendex.js

@@ -3133,7 +3133,7 @@ export default class ascendex extends Exchange {
          * @method
          * @name ascendex#transfer
          * @description transfer currency internally between wallets on the same account
-         * @param {string} code unified currency code
+         * @param {string} code unified currency codeåå
          * @param {float} amount amount to transfer
          * @param {string} fromAccount account to transfer from
          * @param {string} toAccount account to transfer to

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

@@ -3,7 +3,7 @@ import { // eslint-disable-line object-curly-newline
 ExchangeError, AuthenticationError, DDoSProtection, RequestTimeout, ExchangeNotAvailable, RateLimitExceeded } from "./errors.js";
 import WsClient from './ws/WsClient.js';
 import { OrderBook as WsOrderBook, IndexedOrderBook, CountedOrderBook } from './ws/OrderBook.js';
-import type { Market, Trade, Ticker, OHLCV, OHLCVC, Order, OrderBook, Balance, Balances, Dictionary, DepositAddressResponse, Currency, MinMax, IndexType, Int, OrderType, OrderSide, Position, FundingRateHistory, OpenInterest, Liquidation, OrderRequest, FundingHistory, MarginMode, Tickers, Greeks, Str, Num, MarketInterface, CurrencyInterface, Account } from './types.js';
+import type { Market, Trade, Ticker, OHLCV, OHLCVC, Order, OrderBook, Balance, Balances, Dictionary, Transaction, DepositAddressResponse, Currency, MinMax, IndexType, Int, OrderType, OrderSide, Position, FundingRate, DepositWithdrawFeeNetwork, LedgerEntry, BorrowInterest, OpenInterest, LeverageTier, TransferEntry, FundingRateHistory, Liquidation, FundingHistory, OrderRequest, MarginMode, Tickers, Greeks, Str, Num, MarketInterface, CurrencyInterface, Account } from './types.js';
 export type { Market, Trade, Fee, Ticker, OHLCV, OHLCVC, Order, OrderBook, Balance, Balances, Dictionary, Transaction, DepositAddressResponse, Currency, MinMax, IndexType, Int, OrderType, OrderSide, Position, FundingRateHistory, Liquidation, FundingHistory, Greeks } from './types.js';
 /**
  * @class Exchange
@@ -12,6 +12,7 @@ export default class Exchange {
     options: {
         [key: string]: any;
     };
+    throttleProp: any;
     api: any;
     proxy: any;
     proxyUrl: string;
@@ -161,6 +162,7 @@ export default class Exchange {
     clients: {};
     newUpdates: boolean;
     streaming: {};
+    alias: boolean;
     deepExtend: (...xs: any[]) => any;
     isNode: boolean;
     keys: {
@@ -554,6 +556,7 @@ export default class Exchange {
     indexedOrderBook(snapshot?: {}, depth?: number): IndexedOrderBook;
     countedOrderBook(snapshot?: {}, depth?: number): CountedOrderBook;
     handleMessage(client: any, message: any): void;
+    ping(client: any): any;
     client(url: any): WsClient;
     watchMultiple(url: any, messageHashes: any, message?: any, subscribeHashes?: any, subscription?: any): import("./ws/Future.js").FutureInterface;
     watch(url: any, messageHash: any, message?: any, subscribeHash?: any, subscription?: any): any;
@@ -593,7 +596,7 @@ export default class Exchange {
     filterByValueSinceLimit(array: object[], field: IndexType, value?: any, since?: Int, limit?: Int, key?: string, tail?: boolean): any;
     setSandboxMode(enabled: any): void;
     sign(path: any, api?: any, method?: string, params?: {}, headers?: any, body?: any): {};
-    fetchAccounts(params?: {}): Promise<any>;
+    fetchAccounts(params?: {}): Promise<{}>;
     fetchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     fetchTradesWs(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
@@ -602,39 +605,43 @@ export default class Exchange {
     watchOrdersForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     watchOHLCVForSymbols(symbolsAndTimeframes: string[][], since?: Int, limit?: Int, params?: {}): Promise<Dictionary<Dictionary<OHLCV[]>>>;
     watchOrderBookForSymbols(symbols: string[], limit?: Int, params?: {}): Promise<OrderBook>;
-    fetchDepositAddresses(codes?: string[], params?: {}): Promise<any>;
+    fetchDepositAddresses(codes?: string[], params?: {}): Promise<{}>;
     fetchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     fetchMarginMode(symbol?: string, params?: {}): Promise<MarginMode>;
     fetchRestOrderBookSafe(symbol: any, limit?: any, params?: {}): Promise<OrderBook>;
     watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     fetchTime(params?: {}): Promise<Int>;
-    fetchTradingLimits(symbols?: string[], params?: {}): Promise<any>;
+    fetchTradingLimits(symbols?: string[], params?: {}): Promise<{}>;
     parseMarket(market: any): Market;
     parseMarkets(markets: any): Market[];
     parseTicker(ticker: object, market?: Market): Ticker;
-    parseDepositAddress(depositAddress: any, currency?: Currency): void;
+    parseDepositAddress(depositAddress: any, currency?: Currency): object;
     parseTrade(trade: object, market?: Market): Trade;
-    parseTransaction(transaction: any, currency?: Currency): void;
-    parseTransfer(transfer: any, currency?: Currency): void;
-    parseAccount(account: any): void;
-    parseLedgerEntry(item: any, currency?: Currency): void;
+    parseTransaction(transaction: any, currency?: Currency): Transaction;
+    parseTransfer(transfer: any, currency?: Currency): object;
+    parseAccount(account: any): {};
+    parseLedgerEntry(item: any, currency?: Currency): object;
     parseOrder(order: any, market?: Market): Order;
-    fetchCrossBorrowRates(params?: {}): Promise<any>;
-    fetchIsolatedBorrowRates(params?: {}): Promise<any>;
-    parseMarketLeverageTiers(info: any, market?: Market): void;
-    fetchLeverageTiers(symbols?: string[], params?: {}): Promise<any>;
-    parsePosition(position: any, market?: Market): void;
+    fetchCrossBorrowRates(params?: {}): Promise<{}>;
+    fetchIsolatedBorrowRates(params?: {}): Promise<{}>;
+    parseMarketLeverageTiers(info: any, market?: Market): object;
+    fetchLeverageTiers(symbols?: string[], params?: {}): Promise<Dictionary<LeverageTier>>;
+    parsePosition(position: any, market?: Market): Position;
     parseFundingRateHistory(info: any, market?: Market): FundingRateHistory;
-    parseBorrowInterest(info: any, market?: Market): void;
+    parseBorrowInterest(info: any, market?: Market): BorrowInterest;
     parseWsTrade(trade: any, market?: Market): Trade;
     parseWsOrder(order: any, market?: Market): Order;
     parseWsOrderTrade(trade: any, market?: Market): Trade;
     parseWsOHLCV(ohlcv: any, market?: Market): OHLCV;
-    fetchFundingRates(symbols?: string[], params?: {}): Promise<any>;
-    transfer(code: string, amount: any, fromAccount: any, toAccount: any, params?: {}): Promise<any>;
-    withdraw(code: string, amount: any, address: any, tag?: any, params?: {}): Promise<any>;
+    fetchFundingRates(symbols?: string[], params?: {}): Promise<{}>;
+    transfer(code: string, amount: number, fromAccount: string, toAccount: string, params?: {}): Promise<TransferEntry>;
+    withdraw(code: string, amount: number, address: string, tag?: any, params?: {}): Promise<Transaction>;
     createDepositAddress(code: string, params?: {}): Promise<DepositAddressResponse>;
-    setLeverage(leverage: any, symbol?: string, params?: {}): Promise<any>;
+    setLeverage(leverage: Int, symbol?: string, params?: {}): Promise<{}>;
+    fetchOpenInterestHistory(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OpenInterest[]>;
+    fetchOpenInterest(symbol: string, params?: {}): Promise<OpenInterest>;
+    signIn(params?: {}): Promise<{}>;
+    fetchPaymentMethods(params?: {}): Promise<{}>;
     parseToInt(number: any): number;
     parseToNumeric(number: any): number;
     isRoundNumber(value: any): boolean;
@@ -687,13 +694,13 @@ export default class Exchange {
     invertFlatStringDictionary(dict: any): {};
     reduceFeesByCurrency(fees: any): any[];
     safeTicker(ticker: object, market?: Market): Ticker;
-    fetchBorrowRate(code: string, amount: any, params?: {}): Promise<any>;
-    repayCrossMargin(code: string, amount: any, params?: {}): Promise<any>;
-    repayIsolatedMargin(symbol: string, code: string, amount: any, params?: {}): Promise<any>;
-    borrowCrossMargin(code: string, amount: any, params?: {}): Promise<any>;
-    borrowIsolatedMargin(symbol: string, code: string, amount: any, params?: {}): Promise<any>;
-    borrowMargin(code: string, amount: any, symbol?: Str, params?: {}): Promise<any>;
-    repayMargin(code: string, amount: any, symbol?: Str, params?: {}): Promise<any>;
+    fetchBorrowRate(code: string, amount: any, params?: {}): Promise<{}>;
+    repayCrossMargin(code: string, amount: any, params?: {}): Promise<{}>;
+    repayIsolatedMargin(symbol: string, code: string, amount: any, params?: {}): Promise<{}>;
+    borrowCrossMargin(code: string, amount: number, params?: {}): Promise<{}>;
+    borrowIsolatedMargin(symbol: string, code: string, amount: number, params?: {}): Promise<{}>;
+    borrowMargin(code: string, amount: any, symbol?: Str, params?: {}): Promise<{}>;
+    repayMargin(code: string, amount: any, symbol?: Str, params?: {}): Promise<{}>;
     fetchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     fetchOHLCVWs(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
@@ -723,7 +730,7 @@ export default class Exchange {
     parsePositions(positions: any, symbols?: string[], params?: {}): Position[];
     parseAccounts(accounts: any, params?: {}): any[];
     parseTrades(trades: any, market?: Market, since?: Int, limit?: Int, params?: {}): Trade[];
-    parseTransactions(transactions: any, currency?: Currency, since?: Int, limit?: Int, params?: {}): any;
+    parseTransactions(transactions: any, currency?: Currency, since?: Int, limit?: Int, params?: {}): Transaction[];
     parseTransfers(transfers: any, currency?: Currency, since?: Int, limit?: Int, params?: {}): any;
     parseLedger(data: any, currency?: Currency, since?: Int, limit?: Int, params?: {}): any;
     nonce(): number;
@@ -737,12 +744,12 @@ export default class Exchange {
     loadAccounts(reload?: boolean, params?: {}): Promise<any>;
     buildOHLCVC(trades: Trade[], timeframe?: string, since?: number, limit?: number): OHLCVC[];
     parseTradingViewOHLCV(ohlcvs: any, market?: any, timeframe?: string, since?: Int, limit?: Int): OHLCV[];
-    editLimitBuyOrder(id: any, symbol: any, amount: any, price?: any, params?: {}): Promise<Order>;
-    editLimitSellOrder(id: any, symbol: any, amount: any, price?: any, params?: {}): Promise<Order>;
-    editLimitOrder(id: any, symbol: any, side: any, amount: any, price?: any, params?: {}): Promise<Order>;
-    editOrder(id: string, symbol: any, type: any, side: any, amount?: any, price?: any, params?: {}): Promise<Order>;
+    editLimitBuyOrder(id: any, symbol: any, amount: number, price?: number, params?: {}): Promise<Order>;
+    editLimitSellOrder(id: any, symbol: any, amount: number, price?: number, params?: {}): Promise<Order>;
+    editLimitOrder(id: any, symbol: any, side: any, amount: number, price?: number, params?: {}): Promise<Order>;
+    editOrder(id: string, symbol: string, type: OrderType, side: OrderSide, amount?: number, price?: number, params?: {}): Promise<Order>;
     editOrderWs(id: string, symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, params?: {}): Promise<Order>;
-    fetchPermissions(params?: {}): Promise<void>;
+    fetchPermissions(params?: {}): Promise<{}>;
     fetchPosition(symbol: string, params?: {}): Promise<Position>;
     watchPosition(symbol?: string, params?: {}): Promise<Position>;
     watchPositions(symbols?: string[], since?: Int, limit?: Int, params?: {}): Promise<Position[]>;
@@ -751,6 +758,9 @@ export default class Exchange {
     fetchPositions(symbols?: string[], params?: {}): Promise<Position[]>;
     fetchPositionsRisk(symbols?: string[], params?: {}): Promise<Position[]>;
     fetchBidsAsks(symbols?: string[], params?: {}): Promise<Dictionary<Ticker>>;
+    fetchBorrowInterest(code?: string, symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<BorrowInterest[]>;
+    fetchLedger(code?: string, since?: Int, limit?: Int, params?: {}): Promise<LedgerEntry[]>;
+    fetchLedgerEntry(id: string, code?: string, params?: {}): Promise<LedgerEntry>;
     parseBidAsk(bidask: any, priceKey?: IndexType, amountKey?: IndexType, countOrIdKey?: IndexType): number[];
     safeCurrency(currencyId: Str, currency?: Currency): CurrencyInterface;
     safeMarket(marketId: Str, market?: Market, delimiter?: Str, marketType?: Str): MarketInterface;
@@ -765,15 +775,15 @@ export default class Exchange {
     fetchUsedBalance(params?: {}): Promise<Balance>;
     fetchTotalBalance(params?: {}): Promise<Balance>;
     fetchStatus(params?: {}): Promise<any>;
-    fetchFundingFee(code: string, params?: {}): Promise<any>;
-    fetchFundingFees(codes?: string[], params?: {}): Promise<any>;
-    fetchTransactionFee(code: string, params?: {}): Promise<any>;
-    fetchTransactionFees(codes?: string[], params?: {}): Promise<any>;
-    fetchDepositWithdrawFees(codes?: string[], params?: {}): Promise<any>;
-    fetchDepositWithdrawFee(code: string, params?: {}): Promise<any>;
+    fetchFundingFee(code: string, params?: {}): Promise<{}>;
+    fetchFundingFees(codes?: string[], params?: {}): Promise<{}>;
+    fetchTransactionFee(code: string, params?: {}): Promise<{}>;
+    fetchTransactionFees(codes?: string[], params?: {}): Promise<{}>;
+    fetchDepositWithdrawFees(codes?: string[], params?: {}): Promise<Dictionary<DepositWithdrawFeeNetwork>>;
+    fetchDepositWithdrawFee(code: string, params?: {}): Promise<DepositWithdrawFeeNetwork>;
     getSupportedMapping(key: any, mapping?: {}): any;
-    fetchCrossBorrowRate(code: string, params?: {}): Promise<any>;
-    fetchIsolatedBorrowRate(symbol: string, params?: {}): Promise<any>;
+    fetchCrossBorrowRate(code: string, params?: {}): Promise<{}>;
+    fetchIsolatedBorrowRate(symbol: string, params?: {}): Promise<{}>;
     handleOptionAndParams(params: any, methodName: any, optionName: any, defaultValue?: any): any[];
     handleOptionAndParams2(params: any, methodName: any, methodName2: any, optionName: any, defaultValue?: any): any[];
     handleOption(methodName: any, optionName: any, defaultValue?: any): any;
@@ -794,24 +804,24 @@ export default class Exchange {
     fetchOrderWs(id: string, symbol?: string, params?: {}): Promise<Order>;
     fetchOrderStatus(id: string, symbol?: string, params?: {}): Promise<string>;
     fetchUnifiedOrder(order: any, params?: {}): Promise<Order>;
-    createOrder(symbol: string, type: OrderType, side: OrderSide, amount: any, price?: any, params?: {}): Promise<Order>;
+    createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, params?: {}): Promise<Order>;
     createTrailingAmountOrder(symbol: string, type: OrderType, side: OrderSide, amount: any, price?: any, trailingAmount?: any, trailingTriggerPrice?: any, params?: {}): Promise<Order>;
     createTrailingPercentOrder(symbol: string, type: OrderType, side: OrderSide, amount: any, price?: any, trailingPercent?: any, trailingTriggerPrice?: any, params?: {}): Promise<Order>;
-    createMarketOrderWithCost(symbol: string, side: OrderSide, cost: any, params?: {}): Promise<Order>;
-    createMarketBuyOrderWithCost(symbol: string, cost: any, params?: {}): Promise<Order>;
-    createMarketSellOrderWithCost(symbol: string, cost: any, params?: {}): Promise<Order>;
+    createMarketOrderWithCost(symbol: string, side: OrderSide, cost: number, params?: {}): Promise<Order>;
+    createMarketBuyOrderWithCost(symbol: string, cost: number, params?: {}): Promise<Order>;
+    createMarketSellOrderWithCost(symbol: string, cost: number, params?: {}): Promise<Order>;
     createTriggerOrder(symbol: string, type: OrderType, side: OrderSide, amount: any, price?: any, triggerPrice?: any, params?: {}): Promise<Order>;
-    createStopLossOrder(symbol: string, type: OrderType, side: OrderSide, amount: any, price?: any, stopLossPrice?: any, params?: {}): Promise<Order>;
-    createTakeProfitOrder(symbol: string, type: OrderType, side: OrderSide, amount: any, price?: any, takeProfitPrice?: any, params?: {}): Promise<Order>;
-    createOrderWithTakeProfitAndStopLoss(symbol: string, type: OrderType, side: OrderSide, amount: any, price?: any, takeProfit?: any, stopLoss?: any, params?: {}): Promise<Order>;
+    createStopLossOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, stopLossPrice?: number, params?: {}): Promise<Order>;
+    createTakeProfitOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, takeProfitPrice?: number, params?: {}): Promise<Order>;
+    createOrderWithTakeProfitAndStopLoss(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, takeProfit?: number, stopLoss?: number, params?: {}): Promise<Order>;
     createOrders(orders: OrderRequest[], params?: {}): Promise<Order[]>;
     createOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, params?: {}): Promise<Order>;
-    cancelOrder(id: string, symbol?: string, params?: {}): Promise<any>;
-    cancelOrderWs(id: string, symbol?: string, params?: {}): Promise<any>;
-    cancelOrdersWs(ids: string[], symbol?: string, params?: {}): Promise<any>;
-    cancelAllOrders(symbol?: string, params?: {}): Promise<any>;
-    cancelAllOrdersWs(symbol?: string, params?: {}): Promise<any>;
-    cancelUnifiedOrder(order: any, params?: {}): Promise<any>;
+    cancelOrder(id: string, symbol?: string, params?: {}): Promise<{}>;
+    cancelOrderWs(id: string, symbol?: string, params?: {}): Promise<{}>;
+    cancelOrdersWs(ids: string[], symbol?: string, params?: {}): Promise<{}>;
+    cancelAllOrders(symbol?: string, params?: {}): Promise<{}>;
+    cancelAllOrdersWs(symbol?: string, params?: {}): Promise<{}>;
+    cancelUnifiedOrder(order: any, params?: {}): Promise<{}>;
     fetchOrders(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchOrdersWs(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchOrderTrades(id: string, symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
@@ -827,12 +837,11 @@ export default class Exchange {
     fetchMyTradesWs(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     watchMyTrades(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     fetchGreeks(symbol: string, params?: {}): Promise<Greeks>;
-    fetchDepositsWithdrawals(code?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    fetchDeposits(code?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    fetchDepositsWs(code?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    fetchWithdrawals(code?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    fetchWithdrawalsWs(code?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    fetchOpenInterest(symbol: string, params?: {}): Promise<OpenInterest>;
+    fetchDepositsWithdrawals(code?: string, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
+    fetchDeposits(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
+    fetchWithdrawals(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
+    fetchDepositsWs(code?: string, since?: Int, limit?: Int, params?: {}): Promise<{}>;
+    fetchWithdrawalsWs(code?: string, since?: Int, limit?: Int, params?: {}): Promise<{}>;
     fetchFundingRateHistory(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<FundingRateHistory[]>;
     fetchFundingHistory(symbol?: string, since?: Int, limit?: Int, params?: {}): Promise<FundingHistory[]>;
     closePosition(symbol: string, side?: OrderSide, params?: {}): Promise<Order>;
@@ -846,12 +855,12 @@ export default class Exchange {
     market(symbol: string): MarketInterface;
     createExpiredOptionMarket(symbol: string): MarketInterface;
     handleWithdrawTagAndParams(tag: any, params: any): any;
-    createLimitOrder(symbol: string, side: OrderSide, amount: any, price: any, params?: {}): Promise<Order>;
-    createMarketOrder(symbol: string, side: OrderSide, amount: any, price?: any, params?: {}): Promise<Order>;
-    createLimitBuyOrder(symbol: string, amount: any, price: any, params?: {}): Promise<Order>;
-    createLimitSellOrder(symbol: string, amount: any, price: any, params?: {}): Promise<Order>;
-    createMarketBuyOrder(symbol: string, amount: any, params?: {}): Promise<Order>;
-    createMarketSellOrder(symbol: string, amount: any, params?: {}): Promise<Order>;
+    createLimitOrder(symbol: string, side: OrderSide, amount: number, price: number, params?: {}): Promise<Order>;
+    createMarketOrder(symbol: string, side: OrderSide, amount: number, price?: number, params?: {}): Promise<Order>;
+    createLimitBuyOrder(symbol: string, amount: number, price: number, params?: {}): Promise<Order>;
+    createLimitSellOrder(symbol: string, amount: number, price: number, params?: {}): Promise<Order>;
+    createMarketBuyOrder(symbol: string, amount: number, params?: {}): Promise<Order>;
+    createMarketSellOrder(symbol: string, amount: number, params?: {}): Promise<Order>;
     costToPrecision(symbol: string, cost: any): any;
     priceToPrecision(symbol: string, price: any): string;
     amountToPrecision(symbol: string, amount: any): any;
@@ -867,11 +876,11 @@ export default class Exchange {
     loadTimeDifference(params?: {}): Promise<any>;
     implodeHostname(url: string): any;
     fetchMarketLeverageTiers(symbol: string, params?: {}): Promise<any>;
-    createPostOnlyOrder(symbol: string, type: OrderType, side: OrderSide, amount: any, price: any, params?: {}): Promise<Order>;
-    createReduceOnlyOrder(symbol: string, type: OrderType, side: OrderSide, amount: any, price: any, params?: {}): Promise<Order>;
-    createStopOrder(symbol: string, type: OrderType, side: OrderSide, amount: any, price?: any, stopPrice?: any, params?: {}): Promise<Order>;
-    createStopLimitOrder(symbol: string, side: OrderSide, amount: any, price: any, stopPrice: any, params?: {}): Promise<Order>;
-    createStopMarketOrder(symbol: string, side: OrderSide, amount: any, stopPrice: any, params?: {}): Promise<Order>;
+    createPostOnlyOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, params?: {}): Promise<Order>;
+    createReduceOnlyOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, params?: {}): Promise<Order>;
+    createStopOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, stopPrice?: number, params?: {}): Promise<Order>;
+    createStopLimitOrder(symbol: string, side: OrderSide, amount: number, price: number, stopPrice: number, params?: {}): Promise<Order>;
+    createStopMarketOrder(symbol: string, side: OrderSide, amount: number, stopPrice: number, params?: {}): Promise<Order>;
     safeCurrencyCode(currencyId: Str, currency?: Currency): string;
     filterBySymbolSinceLimit(array: any, symbol?: string, since?: Int, limit?: Int, tail?: boolean): any;
     filterByCurrencySinceLimit(array: any, code?: any, since?: Int, limit?: Int, tail?: boolean): any;
@@ -882,18 +891,18 @@ export default class Exchange {
     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;
-    parseFundingRate(contract: string, market?: Market): void;
+    parseFundingRate(contract: string, market?: Market): object;
     parseFundingRates(response: any, market?: Market): {};
     isTriggerOrder(params: any): any[];
     isPostOnly(isMarketOrder: boolean, exchangeSpecificParam: any, params?: {}): boolean;
     handlePostOnly(isMarketOrder: boolean, exchangeSpecificPostOnlyOption: boolean, params?: any): any[];
-    fetchLastPrices(symbols?: string[], params?: {}): Promise<void>;
-    fetchTradingFees(params?: {}): Promise<any>;
-    fetchTradingFeesWs(params?: {}): Promise<any>;
-    fetchTradingFee(symbol: string, params?: {}): Promise<any>;
+    fetchLastPrices(symbols?: string[], params?: {}): Promise<{}>;
+    fetchTradingFees(params?: {}): Promise<{}>;
+    fetchTradingFeesWs(params?: {}): Promise<{}>;
+    fetchTradingFee(symbol: string, params?: {}): Promise<{}>;
     parseOpenInterest(interest: any, market?: Market): OpenInterest;
     parseOpenInterests(response: any, market?: any, since?: Int, limit?: Int): OpenInterest[];
-    fetchFundingRate(symbol: string, params?: {}): Promise<any>;
+    fetchFundingRate(symbol: string, params?: {}): Promise<FundingRate>;
     fetchMarkOHLCV(symbol: any, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     fetchIndexOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     fetchPremiumIndexOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
@@ -905,11 +914,11 @@ export default class Exchange {
     parseDepositWithdrawFee(fee: any, currency?: Currency): any;
     depositWithdrawFee(info: any): any;
     assignDefaultDepositWithdrawFees(fee: any, currency?: any): any;
-    parseIncome(info: any, market?: Market): void;
+    parseIncome(info: any, market?: Market): object;
     parseIncomes(incomes: any, market?: any, since?: Int, limit?: Int): FundingHistory[];
     getMarketFromSymbols(symbols?: string[]): MarketInterface;
     parseWsOHLCVs(ohlcvs: object[], market?: any, timeframe?: string, since?: Int, limit?: Int): any[];
-    fetchTransactions(code?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    fetchTransactions(code?: string, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;
     filterByArrayPositions(objects: any, key: IndexType, values?: any, indexed?: boolean): Position[];
     filterByArrayTickers(objects: any, key: IndexType, values?: any, indexed?: boolean): Dictionary<Ticker>;
     createOHLCVObject(symbol: string, timeframe: string, data: any): Dictionary<Dictionary<OHLCV[]>>;