ccxt 4.4.2 → 4.4.4

package/js/src/pro/phemex.js

@@ -17,7 +17,7 @@ export default class phemex extends phemexRest {
             'has': {
                 'ws': true,
                 'watchTicker': true,
-                'watchTickers': false,
+                'watchTickers': true,
                 'watchTrades': true,
                 'watchMyTrades': true,
                 'watchOrders': true,
@@ -526,6 +526,50 @@ export default class phemex extends phemexRest {
         const request = this.deepExtend(subscribe, params);
         return await this.watch(url, messageHash, request, subscriptionHash);
     }
+    async watchTickers(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name phemex#watchTickers
+         * @see https://github.com/phemex/phemex-api-docs/blob/master/Public-Hedged-Perpetual-API.md#subscribe-24-hours-ticker
+         * @see https://github.com/phemex/phemex-api-docs/blob/master/Public-Contract-API-en.md#subscribe-24-hours-ticker
+         * @see https://github.com/phemex/phemex-api-docs/blob/master/Public-Spot-API-en.md#subscribe-24-hours-ticker
+         * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
+         * @param {string[]} [symbols] unified symbol of the market to fetch the ticker for
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {string} [params.channel] the channel to subscribe to, tickers by default. Can be tickers, sprd-tickers, index-tickers, block-tickers
+         * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+         */
+        await this.loadMarkets();
+        symbols = this.marketSymbols(symbols, undefined, false);
+        const first = symbols[0];
+        const market = this.market(first);
+        const isSwap = market['swap'];
+        const settleIsUSDT = market['settle'] === 'USDT';
+        let name = 'spot_market24h';
+        if (isSwap) {
+            name = settleIsUSDT ? 'perp_market24h_pack_p' : 'market24h';
+        }
+        const url = this.urls['api']['ws'];
+        const requestId = this.requestId();
+        const subscriptionHash = name + '.subscribe';
+        const messageHashes = [];
+        for (let i = 0; i < symbols.length; i++) {
+            messageHashes.push('ticker:' + symbols[i]);
+        }
+        const subscribe = {
+            'method': subscriptionHash,
+            'id': requestId,
+            'params': [],
+        };
+        const request = this.deepExtend(subscribe, params);
+        const ticker = await this.watchMultiple(url, messageHashes, request, messageHashes);
+        if (this.newUpdates) {
+            const result = {};
+            result[ticker['symbol']] = ticker;
+            return result;
+        }
+        return this.filterByArray(this.tickers, 'symbol', symbols);
+    }
     async watchTrades(symbol, since = undefined, limit = undefined, params = {}) {
         /**
          * @method

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

@@ -12,6 +12,9 @@ export default class woofipro extends woofiproRest {
     handleTicker(client: Client, message: any): any;
     watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     handleTickers(client: Client, message: any): void;
+    watchBidsAsks(symbols?: Strings, params?: {}): Promise<Tickers>;
+    handleBidAsk(client: Client, message: any): void;
+    parseWsBidAsk(ticker: any, market?: any): Ticker;
     watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     handleOHLCV(client: Client, message: any): void;
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;

package/js/src/pro/woofipro.js

@@ -24,6 +24,7 @@ export default class woofipro extends woofiproRest {
                 'watchOrders': true,
                 'watchTicker': true,
                 'watchTickers': true,
+                'watchBidsAsks': true,
                 'watchTrades': true,
                 'watchTradesForSymbols': false,
                 'watchPositions': true,
@@ -291,6 +292,71 @@ export default class woofipro extends woofiproRest {
         }
         client.resolve(result, topic);
     }
+    async watchBidsAsks(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name woofipro#watchBidsAsks
+         * @see https://orderly.network/docs/build-on-evm/evm-api/websocket-api/public/bbos
+         * @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);
+        const name = 'bbos';
+        const topic = name;
+        const request = {
+            'event': 'subscribe',
+            'topic': topic,
+        };
+        const message = this.extend(request, params);
+        const tickers = await this.watchPublic(topic, message);
+        return this.filterByArray(tickers, 'symbol', symbols);
+    }
+    handleBidAsk(client, message) {
+        //
+        //     {
+        //       "topic": "bbos",
+        //       "ts": 1726212495000,
+        //       "data": [
+        //         {
+        //           "symbol": "PERP_WOO_USDC",
+        //           "ask": 0.16570,
+        //           "askSize": 4224,
+        //           "bid": 0.16553,
+        //           "bidSize": 6645
+        //         }
+        //       ]
+        //     }
+        //
+        const topic = this.safeString(message, 'topic');
+        const data = this.safeList(message, 'data', []);
+        const timestamp = this.safeInteger(message, 'ts');
+        const result = [];
+        for (let i = 0; i < data.length; i++) {
+            const ticker = this.parseWsBidAsk(this.extend(data[i], { 'ts': timestamp }));
+            this.tickers[ticker['symbol']] = ticker;
+            result.push(ticker);
+        }
+        client.resolve(result, topic);
+    }
+    parseWsBidAsk(ticker, market = undefined) {
+        const marketId = this.safeString(ticker, 'symbol');
+        market = this.safeMarket(marketId, market);
+        const symbol = this.safeString(market, 'symbol');
+        const timestamp = this.safeInteger(ticker, 'ts');
+        return this.safeTicker({
+            'symbol': symbol,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'ask': this.safeString(ticker, 'ask'),
+            'askVolume': this.safeString(ticker, 'askSize'),
+            'bid': this.safeString(ticker, 'bid'),
+            'bidVolume': this.safeString(ticker, 'bidSize'),
+            'info': ticker,
+        }, market);
+    }
     async watchOHLCV(symbol, timeframe = '1m', since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -1205,6 +1271,7 @@ export default class woofipro extends woofiproRest {
             'algoexecutionreport': this.handleOrderUpdate,
             'position': this.handlePositions,
             'balance': this.handleBalance,
+            'bbos': this.handleBidAsk,
         };
         const event = this.safeString(message, 'event');
         let method = this.safeValue(methods, event);

package/js/src/static_dependencies/jsencrypt/lib/jsbn/jsbn.d.ts

@@ -15,7 +15,7 @@ export declare class BigInteger {
     protected intValue(): number;
     protected byteValue(): number;
     protected shortValue(): number;
-    protected signum(): 1 | 0 | -1;
+    protected signum(): 0 | 1 | -1;
     toByteArray(): number[];
     protected equals(a: BigInteger): boolean;
     protected min(a: BigInteger): BigInteger;

package/js/src/static_dependencies/starknet/utils/calldata/parser/index.d.ts

@@ -1,5 +1,5 @@
 import { Abi, FunctionAbi, RawArgs } from '../../../types/index.js';
 import { AbiParserInterface } from './interface.js';
 export declare function createAbiParser(abi: Abi): AbiParserInterface;
-export declare function getAbiVersion(abi: Abi): 1 | 0 | 2;
+export declare function getAbiVersion(abi: Abi): 0 | 1 | 2;
 export declare function isNoConstructorValid(method: string, argsCalldata: RawArgs, abiMethod?: FunctionAbi): boolean;

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;

package/js/src/xt.js

@@ -1138,12 +1138,14 @@ export default class xt extends Exchange {
         let maxCost = undefined;
         let minPrice = undefined;
         let maxPrice = undefined;
+        let amountPrecision = undefined;
         for (let i = 0; i < filters.length; i++) {
             const entry = filters[i];
             const filter = this.safeString(entry, 'filter');
             if (filter === 'QUANTITY') {
                 minAmount = this.safeNumber(entry, 'min');
                 maxAmount = this.safeNumber(entry, 'max');
+                amountPrecision = this.safeNumber(entry, 'tickSize');
             }
             if (filter === 'QUOTE_QTY') {
                 minCost = this.safeNumber(entry, 'min');
@@ -1153,6 +1155,9 @@ export default class xt extends Exchange {
                 maxPrice = this.safeNumber(entry, 'max');
             }
         }
+        if (amountPrecision === undefined) {
+            amountPrecision = this.parseNumber(this.parsePrecision(this.safeString(market, 'quantityPrecision')));
+        }
         const underlyingType = this.safeString(market, 'underlyingType');
         let linear = undefined;
         let inverse = undefined;
@@ -1235,7 +1240,7 @@ export default class xt extends Exchange {
             'optionType': undefined,
             'precision': {
                 'price': this.parseNumber(this.parsePrecision(this.safeString(market, 'pricePrecision'))),
-                'amount': this.parseNumber(this.parsePrecision(this.safeString(market, 'quantityPrecision'))),
+                'amount': amountPrecision,
                 'base': this.parseNumber(this.parsePrecision(this.safeString(market, 'baseCoinPrecision'))),
                 'quote': this.parseNumber(this.parsePrecision(this.safeString(market, 'quoteCoinPrecision'))),
             },
@@ -3595,8 +3600,10 @@ export default class xt extends Exchange {
         const side = this.safeString(item, 'side');
         const direction = (side === 'ADD') ? 'in' : 'out';
         const currencyId = this.safeString(item, 'coin');
+        currency = this.safeCurrency(currencyId, currency);
         const timestamp = this.safeInteger(item, 'createdTime');
-        return {
+        return this.safeLedgerEntry({
+            'info': item,
             'id': this.safeString(item, 'id'),
             'direction': direction,
             'account': undefined,
@@ -3614,8 +3621,7 @@ export default class xt extends Exchange {
                 'currency': undefined,
                 'cost': undefined,
             },
-            'info': item,
-        };
+        }, currency);
     }
     parseLedgerEntryType(type) {
         const ledgerType = {

package/js/src/zonda.d.ts

@@ -1,5 +1,5 @@
 import Exchange from './abstract/zonda.js';
-import type { TransferEntry, Balances, Currency, Int, Market, OHLCV, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction, Num, Dict, int } from './base/types.js';
+import type { TransferEntry, Balances, Currency, Int, Market, OHLCV, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction, Num, Dict, int, LedgerEntry } from './base/types.js';
 /**
  * @class zonda
  * @augments Exchange
@@ -17,24 +17,8 @@ export default class zonda extends Exchange {
     parseTicker(ticker: Dict, market?: Market): Ticker;
     fetchTicker(symbol: string, params?: {}): Promise<Ticker>;
     fetchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
-    fetchLedger(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    parseLedgerEntry(item: Dict, currency?: Currency): {
-        info: Dict;
-        id: string;
-        direction: string;
-        account: any;
-        referenceId: string;
-        referenceAccount: any;
-        type: string;
-        currency: string;
-        amount: number;
-        before: number;
-        after: number;
-        status: string;
-        timestamp: number;
-        datetime: string;
-        fee: any;
-    };
+    fetchLedger(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<LedgerEntry[]>;
+    parseLedgerEntry(item: Dict, currency?: Currency): LedgerEntry;
     parseLedgerEntryType(type: any): string;
     parseOHLCV(ohlcv: any, market?: Market): OHLCV;
     fetchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;

package/js/src/zonda.js

@@ -822,11 +822,11 @@ export default class zonda extends Exchange {
         /**
          * @method
          * @name zonda#fetchLedger
+         * @description fetch the history of changes, actions done by the user or operations that altered the balance of the user
          * @see https://docs.zondacrypto.exchange/reference/operations-history
-         * @description fetch the history of changes, actions done by the user or operations that altered balance of the user
-         * @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}
          */
@@ -1120,6 +1120,7 @@ export default class zonda extends Exchange {
         const timestamp = this.safeInteger(item, 'time');
         const balance = this.safeValue(item, 'balance', {});
         const currencyId = this.safeString(balance, 'currency');
+        currency = this.safeCurrency(currencyId, currency);
         const change = this.safeValue(item, 'change', {});
         let amount = this.safeString(change, 'total');
         let direction = 'in';
@@ -1131,7 +1132,7 @@ export default class zonda extends Exchange {
         // that can be used to enrich the transfers with txid, address etc (you need to use info.detailId as a parameter)
         const fundsBefore = this.safeValue(item, 'fundsBefore', {});
         const fundsAfter = this.safeValue(item, 'fundsAfter', {});
-        return {
+        return this.safeLedgerEntry({
             'info': item,
             'id': this.safeString(item, 'historyId'),
             'direction': direction,
@@ -1147,7 +1148,7 @@ export default class zonda extends Exchange {
             'timestamp': timestamp,
             'datetime': this.iso8601(timestamp),
             'fee': undefined,
-        };
+        }, currency);
     }
     parseLedgerEntryType(type) {
         const types = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccxt",
-  "version": "4.4.2",
+  "version": "4.4.4",
   "description": "A JavaScript / TypeScript / Python / C# / PHP cryptocurrency trading library with support for 100+ exchanges",
   "unpkg": "dist/ccxt.browser.min.js",
   "type": "module",