ccxt 4.4.3 → 4.4.5

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

@@ -3,6 +3,146 @@ import type { Int, OrderSide, OrderType, Str, Strings, Trade, OrderBook, Order,
 import Client from '../base/ws/Client.js';
 export default class binance extends binanceRest {
     describe(): any;
+    describeData(): {
+        has: {
+            ws: boolean;
+            watchBalance: boolean;
+            watchLiquidations: boolean;
+            watchLiquidationsForSymbols: boolean;
+            watchMyLiquidations: boolean;
+            watchMyLiquidationsForSymbols: boolean;
+            watchBidsAsks: boolean;
+            watchMyTrades: boolean;
+            watchOHLCV: boolean;
+            watchOHLCVForSymbols: boolean;
+            watchOrderBook: boolean;
+            watchOrderBookForSymbols: boolean;
+            watchOrders: boolean;
+            watchOrdersForSymbols: boolean;
+            watchPositions: boolean;
+            watchTicker: boolean;
+            watchTickers: boolean;
+            watchTrades: boolean;
+            watchTradesForSymbols: boolean;
+            createOrderWs: boolean;
+            editOrderWs: boolean;
+            cancelOrderWs: boolean;
+            cancelOrdersWs: boolean;
+            cancelAllOrdersWs: boolean;
+            fetchBalanceWs: boolean;
+            fetchDepositsWs: boolean;
+            fetchMarketsWs: boolean;
+            fetchMyTradesWs: boolean;
+            fetchOHLCVWs: boolean;
+            fetchOrderBookWs: boolean;
+            fetchOpenOrdersWs: boolean;
+            fetchOrderWs: boolean;
+            fetchOrdersWs: boolean;
+            fetchPositionWs: boolean;
+            fetchPositionForSymbolWs: boolean;
+            fetchPositionsWs: boolean;
+            fetchTickerWs: boolean;
+            fetchTradesWs: boolean;
+            fetchTradingFeesWs: boolean;
+            fetchWithdrawalsWs: boolean;
+        };
+        urls: {
+            test: {
+                ws: {
+                    spot: string;
+                    margin: string;
+                    future: string;
+                    delivery: string;
+                    'ws-api': {
+                        spot: string;
+                        future: string;
+                    };
+                };
+            };
+            api: {
+                ws: {
+                    spot: string;
+                    margin: string;
+                    future: string;
+                    delivery: string;
+                    'ws-api': {
+                        spot: string;
+                        future: string;
+                    };
+                    papi: string;
+                };
+            };
+            doc: string;
+        };
+        streaming: {
+            keepAlive: number;
+        };
+        options: {
+            returnRateLimits: boolean;
+            streamLimits: {
+                spot: number;
+                margin: number;
+                future: number;
+                delivery: number;
+            };
+            subscriptionLimitByStream: {
+                spot: number;
+                margin: number;
+                future: number;
+                delivery: number;
+            };
+            streamBySubscriptionsHash: {};
+            streamIndex: number;
+            watchOrderBookRate: number;
+            liquidationsLimit: number;
+            myLiquidationsLimit: number;
+            tradesLimit: number;
+            ordersLimit: number;
+            OHLCVLimit: number;
+            requestId: {};
+            watchOrderBookLimit: number;
+            watchTrades: {
+                name: string;
+            };
+            watchTicker: {
+                name: string;
+            };
+            watchTickers: {
+                name: string;
+            };
+            watchOHLCV: {
+                name: string;
+            };
+            watchOrderBook: {
+                maxRetries: number;
+                checksum: boolean;
+            };
+            watchBalance: {
+                fetchBalanceSnapshot: boolean;
+                awaitBalanceSnapshot: boolean;
+            };
+            watchLiquidationsForSymbols: {
+                defaultType: string;
+            };
+            watchPositions: {
+                fetchPositionsSnapshot: boolean;
+                awaitPositionsSnapshot: boolean;
+            };
+            wallet: string;
+            listenKeyRefreshRate: number;
+            ws: {
+                cost: number;
+            };
+            tickerChannelsMap: {
+                '24hrTicker': string;
+                '24hrMiniTicker': string;
+                '1hTicker': string;
+                '4hTicker': string;
+                '1dTicker': string;
+                bookTicker: string;
+            };
+        };
+    };
     requestId(url: any): any;
     stream(type: Str, subscriptionHash: Str, numSubscriptions?: number): string;
     watchLiquidations(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Liquidation[]>;

package/js/src/pro/binance.js

@@ -16,7 +16,11 @@ import { ed25519 } from '../static_dependencies/noble-curves/ed25519.js';
 // -----------------------------------------------------------------------------
 export default class binance extends binanceRest {
     describe() {
-        return this.deepExtend(super.describe(), {
+        const superDescribe = super.describe();
+        return this.deepExtend(superDescribe, this.describeData());
+    }
+    describeData() {
+        return {
             'has': {
                 'ws': true,
                 'watchBalance': true,
@@ -158,7 +162,7 @@ export default class binance extends binanceRest {
                     'bookTicker': 'bookTicker',
                 },
             },
-        });
+        };
     }
     requestId(url) {
         const options = this.safeDict(this.options, 'requestId', this.createSafeDictionary());

package/js/src/pro/binanceus.js

@@ -13,7 +13,8 @@ export default class binanceus extends binance {
         // eslint-disable-next-line new-cap
         const restInstance = new binanceusRest();
         const restDescribe = restInstance.describe();
-        const extended = this.deepExtend(restDescribe, super.describe());
+        const parentWsDescribe = super.describeData();
+        const extended = this.deepExtend(restDescribe, parentWsDescribe);
         return this.deepExtend(extended, {
             'id': 'binanceus',
             'name': 'Binance US',

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

@@ -14,6 +14,8 @@ export default class bybit extends bybitRest {
     unWatchTickers(symbols?: Strings, params?: {}): Promise<any>;
     unWatchTicker(symbols: string, params?: {}): Promise<any>;
     handleTicker(client: Client, message: any): void;
+    watchBidsAsks(symbols?: Strings, params?: {}): Promise<Tickers>;
+    parseWsBidAsk(orderbook: any, market?: any): Ticker;
     watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     watchOHLCVForSymbols(symbolsAndTimeframes: string[][], since?: Int, limit?: Int, params?: {}): Promise<import("../base/types.js").Dictionary<import("../base/types.js").Dictionary<OHLCV[]>>>;
     unWatchOHLCVForSymbols(symbolsAndTimeframes: string[][], params?: {}): Promise<any>;

package/js/src/pro/bybit.js

@@ -25,6 +25,7 @@ export default class bybit extends bybitRest {
                 'fetchTradesWs': false,
                 'fetchBalanceWs': false,
                 'watchBalance': true,
+                'watchBidsAsks': true,
                 'watchLiquidations': true,
                 'watchLiquidationsForSymbols': false,
                 'watchMyLiquidations': false,
@@ -581,6 +582,52 @@ export default class bybit extends bybitRest {
         const messageHash = 'ticker:' + symbol;
         client.resolve(this.tickers[symbol], messageHash);
     }
+    async watchBidsAsks(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name bybit#watchBidsAsks
+         * @description watches best bid & ask for symbols
+         * @see https://bybit-exchange.github.io/docs/v5/websocket/public/orderbook
+         * @param {string[]} symbols unified symbol of the market to fetch the ticker for
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+         */
+        await this.loadMarkets();
+        symbols = this.marketSymbols(symbols, undefined, false);
+        const messageHashes = [];
+        const url = await this.getUrlByMarketType(symbols[0], false, 'watchBidsAsks', params);
+        params = this.cleanParams(params);
+        const marketIds = this.marketIds(symbols);
+        const topics = [];
+        for (let i = 0; i < marketIds.length; i++) {
+            const marketId = marketIds[i];
+            const topic = 'orderbook.1.' + marketId;
+            topics.push(topic);
+            messageHashes.push('bidask:' + symbols[i]);
+        }
+        const ticker = await this.watchTopics(url, messageHashes, topics, params);
+        if (this.newUpdates) {
+            return ticker;
+        }
+        return this.filterByArray(this.bidsasks, 'symbol', symbols);
+    }
+    parseWsBidAsk(orderbook, market = undefined) {
+        const timestamp = this.safeInteger(orderbook, 'timestamp');
+        const bids = this.sortBy(this.aggregate(orderbook['bids']), 0);
+        const asks = this.sortBy(this.aggregate(orderbook['asks']), 0);
+        const bestBid = this.safeList(bids, 0, []);
+        const bestAsk = this.safeList(asks, 0, []);
+        return this.safeTicker({
+            'symbol': market['symbol'],
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'ask': this.safeNumber(bestAsk, 0),
+            'askVolume': this.safeNumber(bestAsk, 1),
+            'bid': this.safeNumber(bestBid, 0),
+            'bidVolume': this.safeNumber(bestBid, 1),
+            'info': orderbook,
+        }, market);
+    }
     async watchOHLCV(symbol, timeframe = '1m', since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -905,6 +952,8 @@ export default class bybit extends bybitRest {
         //         }
         //     }
         //
+        const topic = this.safeString(message, 'topic');
+        const limit = topic.split('.')[1];
         const isSpot = client.url.indexOf('spot') >= 0;
         const type = this.safeString(message, 'type');
         const isSnapshot = (type === 'snapshot');
@@ -933,6 +982,13 @@ export default class bybit extends bybitRest {
         const messageHash = 'orderbook' + ':' + symbol;
         this.orderbooks[symbol] = orderbook;
         client.resolve(orderbook, messageHash);
+        if (limit === '1') {
+            const bidask = this.parseWsBidAsk(this.orderbooks[symbol], market);
+            const newBidsAsks = {};
+            newBidsAsks[symbol] = bidask;
+            this.bidsasks[symbol] = bidask;
+            client.resolve(newBidsAsks, 'bidask:' + symbol);
+        }
     }
     handleDelta(bookside, delta) {
         const bidAsk = this.parseBidAsk(delta, 0, 1);

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

@@ -9,6 +9,7 @@ export default class hyperliquid extends hyperliquidRest {
     watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     unWatchOrderBook(symbol: string, params?: {}): Promise<any>;
     handleOrderBook(client: any, message: any): void;
+    watchTicker(symbol: string, params?: {}): Promise<Ticker>;
     watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     unWatchTickers(symbols?: Strings, params?: {}): Promise<any>;
     watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;

package/js/src/pro/hyperliquid.js

@@ -22,7 +22,7 @@ export default class hyperliquid extends hyperliquidRest {
                 'watchOHLCV': true,
                 'watchOrderBook': true,
                 'watchOrders': true,
-                'watchTicker': false,
+                'watchTicker': true,
                 'watchTickers': true,
                 'watchTrades': true,
                 'watchTradesForSymbols': false,
@@ -238,6 +238,21 @@ export default class hyperliquid extends hyperliquidRest {
         const messageHash = 'orderbook:' + symbol;
         client.resolve(orderbook, messageHash);
     }
+    async watchTicker(symbol, params = {}) {
+        /**
+         * @method
+         * @name hyperliquid#watchTicker
+         * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
+         * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+         * @param {string} symbol unified symbol of the market to fetch the ticker for
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+         */
+        const market = this.market(symbol);
+        symbol = market['symbol'];
+        const tickers = await this.watchTickers([symbol], params);
+        return tickers[symbol];
+    }
     async watchTickers(symbols = undefined, params = {}) {
         /**
          * @method

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

@@ -1,5 +1,5 @@
 import mexcRest from '../mexc.js';
-import type { Int, OHLCV, Str, OrderBook, Order, Trade, Ticker, Balances, Strings, Tickers } from '../base/types.js';
+import type { Int, OHLCV, Str, OrderBook, Order, Trade, Ticker, Balances, Tickers, Strings } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class mexc extends mexcRest {
     describe(): any;
@@ -8,6 +8,9 @@ export default class mexc extends mexcRest {
     watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     handleTickers(client: Client, message: any): void;
     parseWsTicker(ticker: any, market?: any): Ticker;
+    watchBidsAsks(symbols?: Strings, params?: {}): Promise<Tickers>;
+    handleBidAsk(client: Client, message: any): void;
+    parseWsBidAsk(ticker: any, market?: any): Ticker;
     watchSpotPublic(channel: any, messageHash: any, params?: {}): Promise<any>;
     watchSpotPrivate(channel: any, messageHash: any, params?: {}): Promise<any>;
     watchSwapPublic(channel: any, messageHash: any, requestParams: any, params?: {}): Promise<any>;

package/js/src/pro/mexc.js

@@ -6,7 +6,7 @@
 
 //  ---------------------------------------------------------------------------
 import mexcRest from '../mexc.js';
-import { AuthenticationError } from '../base/errors.js';
+import { ArgumentsRequired, AuthenticationError, NotSupported } from '../base/errors.js';
 import { ArrayCache, ArrayCacheBySymbolById, ArrayCacheByTimestamp } from '../base/ws/Cache.js';
 import { sha256 } from '../static_dependencies/noble-hashes/sha256.js';
 //  ---------------------------------------------------------------------------
@@ -31,6 +31,7 @@ export default class mexc extends mexcRest {
                 'watchOrders': true,
                 'watchTicker': true,
                 'watchTickers': true,
+                'watchBidsAsks': true,
                 'watchTrades': true,
                 'watchTradesForSymbols': false,
             },
@@ -110,6 +111,7 @@ export default class mexc extends mexcRest {
         //        "t": 1678643605721
         //    }
         //
+        this.handleBidAsk(client, message);
         const rawTicker = this.safeValue2(message, 'd', 'data');
         const marketId = this.safeString2(message, 's', 'symbol');
         const timestamp = this.safeInteger(message, 't');
@@ -238,6 +240,87 @@ export default class mexc extends mexcRest {
             'info': ticker,
         }, market);
     }
+    async watchBidsAsks(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name mexc#watchBidsAsks
+         * @see https://mexcdevelop.github.io/apidocs/spot_v3_en/#individual-symbol-book-ticker-streams
+         * @description watches best bid & ask for symbols
+         * @param {string[]} symbols unified symbol of the market to fetch the ticker for
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+         */
+        await this.loadMarkets();
+        symbols = this.marketSymbols(symbols, undefined, true, false, true);
+        let marketType = undefined;
+        if (symbols === undefined) {
+            throw new ArgumentsRequired(this.id + 'watchBidsAsks required symbols argument');
+        }
+        const markets = this.marketsForSymbols(symbols);
+        [marketType, params] = this.handleMarketTypeAndParams('watchBidsAsks', markets[0], params);
+        const isSpot = marketType === 'spot';
+        if (!isSpot) {
+            throw new NotSupported(this.id + 'watchBidsAsks only support spot market');
+        }
+        const messageHashes = [];
+        const topics = [];
+        for (let i = 0; i < symbols.length; i++) {
+            if (isSpot) {
+                const market = this.market(symbols[i]);
+                topics.push('spot@public.bookTicker.v3.api@' + market['id']);
+            }
+            messageHashes.push('bidask:' + symbols[i]);
+        }
+        const url = this.urls['api']['ws']['spot'];
+        const request = {
+            'method': 'SUBSCRIPTION',
+            'params': topics,
+        };
+        const ticker = await this.watchMultiple(url, messageHashes, this.extend(request, params), messageHashes);
+        if (this.newUpdates) {
+            const tickers = {};
+            tickers[ticker['symbol']] = ticker;
+            return tickers;
+        }
+        return this.filterByArray(this.bidsasks, 'symbol', symbols);
+    }
+    handleBidAsk(client, message) {
+        //
+        //    {
+        //        "c": "spot@public.bookTicker.v3.api@BTCUSDT",
+        //        "d": {
+        //            "A": "4.70432",
+        //            "B": "6.714863",
+        //            "a": "20744.54",
+        //            "b": "20744.17"
+        //        },
+        //        "s": "BTCUSDT",
+        //        "t": 1678643605721
+        //    }
+        //
+        const parsedTicker = this.parseWsBidAsk(message);
+        const symbol = parsedTicker['symbol'];
+        this.bidsasks[symbol] = parsedTicker;
+        const messageHash = 'bidask:' + symbol;
+        client.resolve(parsedTicker, messageHash);
+    }
+    parseWsBidAsk(ticker, market = undefined) {
+        const data = this.safeDict(ticker, 'd');
+        const marketId = this.safeString(ticker, 's');
+        market = this.safeMarket(marketId, market);
+        const symbol = this.safeString(market, 'symbol');
+        const timestamp = this.safeInteger(ticker, 't');
+        return this.safeTicker({
+            'symbol': symbol,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'ask': this.safeNumber(data, 'a'),
+            'askVolume': this.safeNumber(data, 'A'),
+            'bid': this.safeNumber(data, 'b'),
+            'bidVolume': this.safeNumber(data, 'B'),
+            'info': ticker,
+        }, market);
+    }
     async watchSpotPublic(channel, messageHash, params = {}) {
         const url = this.urls['api']['ws']['spot'];
         const request = {

package/js/src/pro/paradex.js

@@ -224,6 +224,7 @@ export default class paradex extends paradexRest {
          * @method
          * @name paradex#watchTickers
          * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
+         * @see https://docs.api.testnet.paradex.trade/#sub-markets_summary-operation
          * @param {string[]} symbols unified symbol of the market to fetch the ticker for
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}

package/js/src/woo.d.ts

@@ -1,5 +1,5 @@
 import Exchange from './abstract/woo.js';
-import type { TransferEntry, Balances, Conversion, Currency, FundingRateHistory, Int, Market, MarginModification, Num, OHLCV, Order, OrderBook, OrderSide, OrderType, Str, Dict, Strings, Trade, Transaction, Leverage, Account, Currencies, TradingFees, int, FundingHistory } from './base/types.js';
+import type { TransferEntry, Balances, Conversion, Currency, FundingRateHistory, Int, Market, MarginModification, Num, OHLCV, Order, OrderBook, OrderSide, OrderType, Str, Dict, Strings, Trade, Transaction, Leverage, Account, Currencies, TradingFees, int, FundingHistory, LedgerEntry } from './base/types.js';
 /**
  * @class woo
  * @augments Exchange
@@ -61,24 +61,8 @@ export default class woo extends Exchange {
         info: any;
     }>;
     getAssetHistoryRows(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    fetchLedger(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    parseLedgerEntry(item: Dict, currency?: Currency): {
-        id: string;
-        currency: any;
-        account: string;
-        referenceAccount: any;
-        referenceId: string;
-        status: string;
-        amount: number;
-        before: any;
-        after: any;
-        fee: any;
-        direction: string;
-        timestamp: number;
-        datetime: string;
-        type: string;
-        info: Dict;
-    };
+    fetchLedger(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<LedgerEntry[]>;
+    parseLedgerEntry(item: Dict, currency?: Currency): LedgerEntry;
     parseLedgerEntryType(type: any): string;
     getCurrencyFromChaincode(networkizedCode: any, currency: any): any;
     fetchDeposits(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;

package/js/src/woo.js

@@ -2144,9 +2144,9 @@ export default class woo extends Exchange {
          * @name woo#fetchLedger
          * @description fetch the history of changes, actions done by the user or operations that altered balance of the user
          * @see https://docs.woo.org/#get-asset-history
-         * @param {string} code unified currency code, default is undefined
+         * @param {string} [code] unified currency code, default is undefined
          * @param {int} [since] timestamp in ms of the earliest ledger entry, default is undefined
-         * @param {int} [limit] max number of ledger entrys to return, default is undefined
+         * @param {int} [limit] max number of ledger entries to return, default is undefined
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @returns {object} a [ledger structure]{@link https://docs.ccxt.com/#/?id=ledger-structure}
          */
@@ -2157,12 +2157,14 @@ export default class woo extends Exchange {
         const networkizedCode = this.safeString(item, 'token');
         const currencyDefined = this.getCurrencyFromChaincode(networkizedCode, currency);
         const code = currencyDefined['code'];
+        currency = this.safeCurrency(code, currency);
         const amount = this.safeNumber(item, 'amount');
         const side = this.safeString(item, 'token_side');
         const direction = (side === 'DEPOSIT') ? 'in' : 'out';
         const timestamp = this.safeTimestamp(item, 'created_time');
         const fee = this.parseTokenAndFeeTemp(item, 'fee_token', 'fee_amount');
-        return {
+        return this.safeLedgerEntry({
+            'info': item,
             'id': this.safeString(item, 'id'),
             'currency': code,
             'account': this.safeString(item, 'account'),
@@ -2172,13 +2174,12 @@ export default class woo extends Exchange {
             'amount': amount,
             'before': undefined,
             'after': undefined,
-            'fee': fee,
             'direction': direction,
             'timestamp': timestamp,
             'datetime': this.iso8601(timestamp),
             'type': this.parseLedgerEntryType(this.safeString(item, 'type')),
-            'info': item,
-        };
+            'fee': fee,
+        }, currency);
     }
     parseLedgerEntryType(type) {
         const types = {

package/js/src/woofipro.d.ts

@@ -1,5 +1,5 @@
 import Exchange from './abstract/woofipro.js';
-import type { Balances, Currency, FundingRateHistory, Int, Market, Num, OHLCV, Order, OrderBook, OrderSide, OrderType, Str, Strings, Trade, Transaction, Leverage, Currencies, TradingFees, OrderRequest, Dict, int } from './base/types.js';
+import type { Balances, Currency, FundingRateHistory, Int, Market, Num, OHLCV, Order, OrderBook, OrderSide, OrderType, Str, Strings, Trade, Transaction, Leverage, Currencies, TradingFees, OrderRequest, Dict, int, LedgerEntry } from './base/types.js';
 /**
  * @class woofipro
  * @augments Exchange
@@ -87,25 +87,9 @@ export default class woofipro extends Exchange {
     parseBalance(response: any): Balances;
     fetchBalance(params?: {}): Promise<Balances>;
     getAssetHistoryRows(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    parseLedgerEntry(item: Dict, currency?: Currency): {
-        id: string;
-        currency: string;
-        account: string;
-        referenceAccount: any;
-        referenceId: string;
-        status: string;
-        amount: number;
-        before: any;
-        after: any;
-        fee: any;
-        direction: string;
-        timestamp: number;
-        datetime: string;
-        type: string;
-        info: Dict;
-    };
+    parseLedgerEntry(item: Dict, currency?: Currency): LedgerEntry;
     parseLedgerEntryType(type: any): string;
-    fetchLedger(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    fetchLedger(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<LedgerEntry[]>;
     parseTransaction(transaction: Dict, currency?: Currency): Transaction;
     parseTransactionStatus(status: Str): string;
     fetchDeposits(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;

package/js/src/woofipro.js

@@ -2122,13 +2122,15 @@ export default class woofipro extends Exchange {
         return [currency, this.safeList(data, 'rows', [])];
     }
     parseLedgerEntry(item, currency = undefined) {
-        const code = this.safeString(item, 'token');
+        const currencyId = this.safeString(item, 'token');
+        const code = this.safeCurrencyCode(currencyId, currency);
+        currency = this.safeCurrency(currencyId, currency);
         const amount = this.safeNumber(item, 'amount');
         const side = this.safeString(item, 'token_side');
         const direction = (side === 'DEPOSIT') ? 'in' : 'out';
         const timestamp = this.safeInteger(item, 'created_time');
         const fee = this.parseTokenAndFeeTemp(item, 'fee_token', 'fee_amount');
-        return {
+        return this.safeLedgerEntry({
             'id': this.safeString(item, 'id'),
             'currency': code,
             'account': this.safeString(item, 'account'),
@@ -2144,7 +2146,7 @@ export default class woofipro extends Exchange {
             'datetime': this.iso8601(timestamp),
             'type': this.parseLedgerEntryType(this.safeString(item, 'type')),
             'info': item,
-        };
+        }, currency);
     }
     parseLedgerEntryType(type) {
         const types = {
@@ -2157,11 +2159,11 @@ export default class woofipro extends Exchange {
         /**
          * @method
          * @name woofipro#fetchLedger
-         * @description fetch the history of changes, actions done by the user or operations that altered balance of the user
+         * @description fetch the history of changes, actions done by the user or operations that altered the balance of the user
          * @see https://orderly.network/docs/build-on-evm/evm-api/restful-api/private/get-asset-history
-         * @param {string} code unified currency code, default is undefined
+         * @param {string} [code] unified currency code, default is undefined
          * @param {int} [since] timestamp in ms of the earliest ledger entry, default is undefined
-         * @param {int} [limit] max number of ledger entrys to return, default is undefined
+         * @param {int} [limit] max number of ledger entries to return, default is undefined
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @returns {object} a [ledger structure]{@link https://docs.ccxt.com/#/?id=ledger-structure}
          */

package/js/src/xt.d.ts

@@ -1,5 +1,5 @@
 import Exchange from './abstract/xt.js';
-import { Currencies, Currency, Dict, FundingHistory, FundingRateHistory, Int, LeverageTier, MarginModification, Market, Num, OHLCV, Order, OrderSide, OrderType, Str, Tickers, Transaction, TransferEntry } from './base/types.js';
+import { Currencies, Currency, Dict, FundingHistory, FundingRateHistory, Int, LeverageTier, MarginModification, Market, Num, OHLCV, Order, OrderSide, OrderType, Str, Tickers, Transaction, TransferEntry, LedgerEntry } from './base/types.js';
 /**
  * @class xt
  * @augments Exchange
@@ -41,27 +41,8 @@ export default class xt extends Exchange {
     cancelOrders(ids: string[], symbol?: string, params?: {}): Promise<Order[]>;
     parseOrder(order: any, market?: any): Order;
     parseOrderStatus(status: any): string;
-    fetchLedger(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    parseLedgerEntry(item: any, currency?: any): {
-        id: string;
-        direction: string;
-        account: any;
-        referenceId: any;
-        referenceAccount: any;
-        type: string;
-        currency: string;
-        amount: number;
-        timestamp: number;
-        datetime: string;
-        before: any;
-        after: number;
-        status: any;
-        fee: {
-            currency: any;
-            cost: any;
-        };
-        info: any;
-    };
+    fetchLedger(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<LedgerEntry[]>;
+    parseLedgerEntry(item: any, currency?: any): LedgerEntry;
     parseLedgerEntryType(type: any): string;
     fetchDepositAddress(code: string, params?: {}): Promise<{
         currency: string;