ccxt 4.4.8 → 4.4.9

package/js/src/pro/hitbtc.js

@@ -17,6 +17,7 @@ export default class hitbtc extends hitbtcRest {
                 'ws': true,
                 'watchTicker': true,
                 'watchTickers': true,
+                'watchBidsAsks': true,
                 'watchTrades': true,
                 'watchTradesForSymbols': false,
                 'watchOrderBook': true,
@@ -51,8 +52,11 @@ export default class hitbtc extends hitbtcRest {
                 'watchTickers': {
                     'method': 'ticker/{speed}', // 'ticker/{speed}','ticker/price/{speed}', 'ticker/{speed}/batch', or 'ticker/{speed}/price/batch''
                 },
+                'watchBidsAsks': {
+                    'method': 'orderbook/top/{speed}', // 'orderbook/top/{speed}', 'orderbook/top/{speed}/batch'
+                },
                 'watchOrderBook': {
-                    'method': 'orderbook/full', // 'orderbook/full', 'orderbook/{depth}/{speed}', 'orderbook/{depth}/{speed}/batch', 'orderbook/top/{speed}', or 'orderbook/top/{speed}/batch'
+                    'method': 'orderbook/full', // 'orderbook/full', 'orderbook/{depth}/{speed}', 'orderbook/{depth}/{speed}/batch'
                 },
             },
             'timeframes': {
@@ -128,10 +132,17 @@ export default class hitbtc extends hitbtcRest {
          * @param {object} [params] extra parameters specific to the hitbtc api
          */
         await this.loadMarkets();
+        symbols = this.marketSymbols(symbols);
+        const isBatch = name.indexOf('batch') >= 0;
         const url = this.urls['api']['ws']['public'];
-        let messageHash = messageHashPrefix;
-        if (symbols !== undefined) {
-            messageHash = messageHash + '::' + symbols.join(',');
+        const messageHashes = [];
+        if (symbols !== undefined && !isBatch) {
+            for (let i = 0; i < symbols.length; i++) {
+                messageHashes.push(messageHashPrefix + '::' + symbols[i]);
+            }
+        }
+        else {
+            messageHashes.push(messageHashPrefix);
         }
         const subscribe = {
             'method': 'subscribe',
@@ -139,7 +150,7 @@ export default class hitbtc extends hitbtcRest {
             'ch': name,
         };
         const request = this.extend(subscribe, params);
-        return await this.watch(url, messageHash, request, messageHash);
+        return await this.watchMultiple(url, messageHashes, request, messageHashes);
     }
     async subscribePrivate(name, symbol = undefined, params = {}) {
         /**
@@ -196,7 +207,7 @@ export default class hitbtc extends hitbtcRest {
          * @param {string} symbol unified symbol of the market to fetch the order book for
          * @param {int} [limit] the maximum amount of order book entries to return
          * @param {object} [params] extra parameters specific to the exchange API endpoint
-         * @param {string} [params.method] 'orderbook/full', 'orderbook/{depth}/{speed}', 'orderbook/{depth}/{speed}/batch', 'orderbook/top/{speed}', or 'orderbook/top/{speed}/batch'
+         * @param {string} [params.method] 'orderbook/full', 'orderbook/{depth}/{speed}', 'orderbook/{depth}/{speed}/batch'
          * @param {int} [params.depth] 5 , 10, or 20 (default)
          * @param {int} [params.speed] 100 (default), 500, or 1000
          * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
@@ -212,12 +223,6 @@ export default class hitbtc extends hitbtcRest {
         else if (name === 'orderbook/{depth}/{speed}/batch') {
             name = 'orderbook/D' + depth + '/' + speed + 'ms/batch';
         }
-        else if (name === 'orderbook/top/{speed}') {
-            name = 'orderbook/top/' + speed + 'ms';
-        }
-        else if (name === 'orderbook/top/{speed}/batch') {
-            name = 'orderbook/top/' + speed + 'ms/batch';
-        }
         const market = this.market(symbol);
         const request = {
             'params': {
@@ -313,20 +318,8 @@ export default class hitbtc extends hitbtcRest {
          * @param {string} [params.speed] '1s' (default), or '3s'
          * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
          */
-        const options = this.safeValue(this.options, 'watchTicker');
-        const defaultMethod = this.safeString(options, 'method', 'ticker/{speed}');
-        const method = this.safeString2(params, 'method', 'defaultMethod', defaultMethod);
-        const speed = this.safeString(params, 'speed', '1s');
-        const name = this.implodeParams(method, { 'speed': speed });
-        params = this.omit(params, ['method', 'speed']);
-        const market = this.market(symbol);
-        const request = {
-            'params': {
-                'symbols': [market['id']],
-            },
-        };
-        const result = await this.subscribePublic(name, 'tickers', [symbol], this.deepExtend(request, params));
-        return this.safeValue(result, symbol);
+        const ticker = await this.watchTickers([symbol], params);
+        return this.safeValue(ticker, symbol);
     }
     async watchTickers(symbols = undefined, params = {}) {
         /**
@@ -335,13 +328,14 @@ export default class hitbtc extends hitbtcRest {
          * @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
-         * @param {string} params.method 'ticker/{speed}' (default),'ticker/price/{speed}', 'ticker/{speed}/batch', or 'ticker/{speed}/price/batch''
+         * @param {string} params.method 'ticker/{speed}' ,'ticker/price/{speed}', 'ticker/{speed}/batch' (default), or 'ticker/{speed}/price/batch''
          * @param {string} params.speed '1s' (default), or '3s'
          * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/en/latest/manual.html#ticker-structure}
          */
         await this.loadMarkets();
+        symbols = this.marketSymbols(symbols);
         const options = this.safeValue(this.options, 'watchTicker');
-        const defaultMethod = this.safeString(options, 'method', 'ticker/{speed}');
+        const defaultMethod = this.safeString(options, 'method', 'ticker/{speed}/batch');
         const method = this.safeString2(params, 'method', 'defaultMethod', defaultMethod);
         const speed = this.safeString(params, 'speed', '1s');
         const name = this.implodeParams(method, { 'speed': speed });
@@ -361,11 +355,15 @@ export default class hitbtc extends hitbtcRest {
                 'symbols': marketIds,
             },
         };
-        const tickers = await this.subscribePublic(name, 'tickers', symbols, this.deepExtend(request, params));
+        const newTickers = await this.subscribePublic(name, 'tickers', symbols, this.deepExtend(request, params));
         if (this.newUpdates) {
-            return tickers;
+            if (!Array.isArray(newTickers)) {
+                const tickers = {};
+                tickers[newTickers['symbol']] = newTickers;
+                return tickers;
+            }
         }
-        return this.filterByArray(this.tickers, 'symbol', symbols);
+        return this.filterByArray(newTickers, 'symbol', symbols);
     }
     handleTicker(client, message) {
         //
@@ -408,30 +406,19 @@ export default class hitbtc extends hitbtcRest {
         //
         const data = this.safeValue(message, 'data', {});
         const marketIds = Object.keys(data);
-        const newTickers = {};
+        const result = [];
+        const topic = 'tickers';
         for (let i = 0; i < marketIds.length; i++) {
             const marketId = marketIds[i];
             const market = this.safeMarket(marketId);
             const symbol = market['symbol'];
             const ticker = this.parseWsTicker(data[marketId], market);
             this.tickers[symbol] = ticker;
-            newTickers[symbol] = ticker;
-        }
-        client.resolve(newTickers, 'tickers');
-        const messageHashes = this.findMessageHashes(client, 'tickers::');
-        for (let i = 0; i < messageHashes.length; i++) {
-            const messageHash = messageHashes[i];
-            const parts = messageHash.split('::');
-            const symbolsString = parts[1];
-            const symbols = symbolsString.split(',');
-            const tickers = this.filterByArray(newTickers, 'symbol', symbols);
-            const tickersSymbols = Object.keys(tickers);
-            const numTickers = tickersSymbols.length;
-            if (numTickers > 0) {
-                client.resolve(tickers, messageHash);
-            }
+            result.push(ticker);
+            const messageHash = topic + '::' + symbol;
+            client.resolve(ticker, messageHash);
         }
-        return message;
+        client.resolve(result, topic);
     }
     parseWsTicker(ticker, market = undefined) {
         //
@@ -488,6 +475,86 @@ export default class hitbtc extends hitbtcRest {
             'info': ticker,
         }, market);
     }
+    async watchBidsAsks(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name hitbtc#watchBidsAsks
+         * @description watches best bid & ask for symbols
+         * @see https://api.hitbtc.com/#subscribe-to-top-of-book
+         * @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.method] 'orderbook/top/{speed}' or 'orderbook/top/{speed}/batch (default)'
+         * @param {string} [params.speed] '100ms' (default) or '500ms' or '1000ms'
+         * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+         */
+        await this.loadMarkets();
+        symbols = this.marketSymbols(symbols, undefined, false);
+        const options = this.safeValue(this.options, 'watchBidsAsks');
+        const defaultMethod = this.safeString(options, 'method', 'orderbook/top/{speed}/batch');
+        const method = this.safeString2(params, 'method', 'defaultMethod', defaultMethod);
+        const speed = this.safeString(params, 'speed', '100ms');
+        const name = this.implodeParams(method, { 'speed': speed });
+        params = this.omit(params, ['method', 'speed']);
+        const marketIds = this.marketIds(symbols);
+        const request = {
+            'params': {
+                'symbols': marketIds,
+            },
+        };
+        const newTickers = await this.subscribePublic(name, 'bidask', symbols, this.deepExtend(request, params));
+        if (this.newUpdates) {
+            if (!Array.isArray(newTickers)) {
+                const tickers = {};
+                tickers[newTickers['symbol']] = newTickers;
+                return tickers;
+            }
+        }
+        return this.filterByArray(newTickers, 'symbol', symbols);
+    }
+    handleBidAsk(client, message) {
+        //
+        //     {
+        //         "ch": "orderbook/top/100ms", // or 'orderbook/top/100ms/batch'
+        //         "data": {
+        //             "BTCUSDT": {
+        //                 "t": 1727276919771,
+        //                 "a": "63931.45",
+        //                 "A": "0.02879",
+        //                 "b": "63926.97",
+        //                 "B": "0.00100"
+        //             }
+        //         }
+        //     }
+        //
+        const data = this.safeDict(message, 'data', {});
+        const marketIds = Object.keys(data);
+        const result = [];
+        const topic = 'bidask';
+        for (let i = 0; i < marketIds.length; i++) {
+            const marketId = marketIds[i];
+            const market = this.safeMarket(marketId);
+            const symbol = market['symbol'];
+            const ticker = this.parseWsBidAsk(data[marketId], market);
+            this.bidsasks[symbol] = ticker;
+            result.push(ticker);
+            const messageHash = topic + '::' + symbol;
+            client.resolve(ticker, messageHash);
+        }
+        client.resolve(result, topic);
+    }
+    parseWsBidAsk(ticker, market = undefined) {
+        const timestamp = this.safeInteger(ticker, 't');
+        return this.safeTicker({
+            'symbol': market['symbol'],
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'ask': this.safeString(ticker, 'a'),
+            'askVolume': this.safeString(ticker, 'A'),
+            'bid': this.safeString(ticker, 'b'),
+            'bidVolume': this.safeString(ticker, 'B'),
+            'info': ticker,
+        }, market);
+    }
     async watchTrades(symbol, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -1223,11 +1290,18 @@ export default class hitbtc extends hitbtcRest {
         if (channel !== undefined) {
             const splitChannel = channel.split('/');
             channel = this.safeString(splitChannel, 0);
+            if (channel === 'orderbook') {
+                const channel2 = this.safeString(splitChannel, 1);
+                if (channel2 !== undefined && channel2 === 'top') {
+                    channel = 'orderbook/top';
+                }
+            }
             const methods = {
                 'candles': this.handleOHLCV,
                 'ticker': this.handleTicker,
                 'trades': this.handleTrades,
                 'orderbook': this.handleOrderBook,
+                'orderbook/top': this.handleBidAsk,
                 'spot_order': this.handleOrder,
                 'spot_orders': this.handleOrder,
                 'margin_order': this.handleOrder,

package/js/src/pro/hollaex.js

@@ -59,6 +59,7 @@ export default class hollaex extends hollaexRest {
          * @method
          * @name hollaex#watchOrderBook
          * @description watches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
+         * @see https://apidocs.hollaex.com/#sending-receiving-messages
          * @param {string} symbol unified symbol of the market to fetch the order book for
          * @param {int} [limit] the maximum amount of order book entries to return
          * @param {object} [params] extra parameters specific to the exchange API endpoint
@@ -117,6 +118,7 @@ export default class hollaex extends hollaexRest {
          * @method
          * @name hollaex#watchTrades
          * @description get the list of most recent trades for a particular symbol
+         * @see https://apidocs.hollaex.com/#sending-receiving-messages
          * @param {string} symbol unified symbol of the market to fetch trades for
          * @param {int} [since] timestamp in ms of the earliest trade to fetch
          * @param {int} [limit] the maximum amount of trades to fetch
@@ -173,6 +175,7 @@ export default class hollaex extends hollaexRest {
          * @method
          * @name hollaex#watchMyTrades
          * @description watches information on multiple trades made by the user
+         * @see https://apidocs.hollaex.com/#sending-receiving-messages
          * @param {string} symbol unified market symbol of the market trades were made in
          * @param {int} [since] the earliest time in ms to fetch trades for
          * @param {int} [limit] the maximum number of trade structures to retrieve
@@ -253,6 +256,7 @@ export default class hollaex extends hollaexRest {
          * @method
          * @name hollaex#watchOrders
          * @description watches information on multiple orders made by the user
+         * @see https://apidocs.hollaex.com/#sending-receiving-messages
          * @param {string} symbol unified market symbol of the market orders were made in
          * @param {int} [since] the earliest time in ms to fetch orders for
          * @param {int} [limit] the maximum number of order structures to retrieve
@@ -374,6 +378,7 @@ export default class hollaex extends hollaexRest {
          * @method
          * @name hollaex#watchBalance
          * @description watch balance and get the amount of funds available for trading or funds locked in orders
+         * @see https://apidocs.hollaex.com/#sending-receiving-messages
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @returns {object} a [balance structure]{@link https://docs.ccxt.com/#/?id=balance-structure}
          */

package/js/src/pro/okx.js

@@ -2214,15 +2214,31 @@ export default class okx extends okxRest {
         //     { event: 'error', msg: "Illegal request: {"op":"subscribe","args":["spot/ticker:BTC-USDT"]}", code: "60012" }
         //     { event: 'error", msg: "channel:ticker,instId:BTC-USDT doesn"t exist", code: "60018" }
         //
-        const errorCode = this.safeString(message, 'code');
+        let errorCode = this.safeString(message, 'code');
         try {
             if (errorCode && errorCode !== '0') {
                 const feedback = this.id + ' ' + this.json(message);
-                this.throwExactlyMatchedException(this.exceptions['exact'], errorCode, feedback);
-                const messageString = this.safeValue(message, 'msg');
+                if (errorCode !== '1') {
+                    this.throwExactlyMatchedException(this.exceptions['exact'], errorCode, feedback);
+                }
+                let messageString = this.safeValue(message, 'msg');
                 if (messageString !== undefined) {
                     this.throwBroadlyMatchedException(this.exceptions['broad'], messageString, feedback);
                 }
+                else {
+                    const data = this.safeList(message, 'data', []);
+                    for (let i = 0; i < data.length; i++) {
+                        const d = data[i];
+                        errorCode = this.safeString(d, 'sCode');
+                        if (errorCode !== undefined) {
+                            this.throwExactlyMatchedException(this.exceptions['exact'], errorCode, feedback);
+                        }
+                        messageString = this.safeValue(message, 'sMsg');
+                        if (messageString !== undefined) {
+                            this.throwBroadlyMatchedException(this.exceptions['broad'], messageString, feedback);
+                        }
+                    }
+                }
                 throw new ExchangeError(feedback);
             }
         }

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

@@ -1,11 +1,12 @@
 import p2bRest from '../p2b.js';
-import type { Int, OHLCV, OrderBook, Trade, Ticker } from '../base/types.js';
+import type { Int, OHLCV, OrderBook, Trade, Ticker, Strings, Tickers } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class p2b extends p2bRest {
     describe(): any;
     subscribe(name: string, messageHash: string, request: any, params?: {}): Promise<any>;
     watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     watchTicker(symbol: string, params?: {}): Promise<Ticker>;
+    watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     watchTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;

package/js/src/pro/p2b.js

@@ -30,7 +30,7 @@ export default class p2b extends p2bRest {
                 'watchOrders': false,
                 // 'watchStatus': true,
                 'watchTicker': true,
-                'watchTickers': false,
+                'watchTickers': true,
                 'watchTrades': true,
                 'watchTradesForSymbols': true,
             },
@@ -136,6 +136,39 @@ export default class p2b extends p2bRest {
         const messageHash = name + '::' + market['symbol'];
         return await this.subscribe(name + '.subscribe', messageHash, request, params);
     }
+    async watchTickers(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name p2b#watchTickers
+         * @see https://github.com/P2B-team/P2B-WSS-Public/blob/main/wss_documentation.md#last-price
+         * @see https://github.com/P2B-team/P2B-WSS-Public/blob/main/wss_documentation.md#market-status
+         * @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 {object} [params.method] 'state' (default) or 'price'
+         * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+         */
+        await this.loadMarkets();
+        symbols = this.marketSymbols(symbols, undefined, false);
+        const watchTickerOptions = this.safeDict(this.options, 'watchTicker');
+        let name = this.safeString(watchTickerOptions, 'name', 'state'); // or price
+        [name, params] = this.handleOptionAndParams(params, 'method', 'name', name);
+        const messageHashes = [];
+        const args = [];
+        for (let i = 0; i < symbols.length; i++) {
+            const market = this.market(symbols[i]);
+            messageHashes.push(name + '::' + market['symbol']);
+            args.push(market['id']);
+        }
+        const url = this.urls['api']['ws'];
+        const request = {
+            'method': name + '.subscribe',
+            'params': args,
+            'id': this.milliseconds(),
+        };
+        await this.watchMultiple(url, messageHashes, this.extend(request, params), messageHashes);
+        return this.filterByArray(this.tickers, 'symbol', symbols);
+    }
     async watchTrades(symbol, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -351,6 +384,7 @@ export default class p2b extends p2bRest {
             ticker = this.parseTicker(tickerData, market);
         }
         const symbol = ticker['symbol'];
+        this.tickers[symbol] = ticker;
         const messageHash = messageHashStart + '::' + symbol;
         client.resolve(ticker, messageHash);
         return message;

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

@@ -1,5 +1,5 @@
 import whitebitRest from '../whitebit.js';
-import type { Int, Str, OrderBook, Order, Trade, Ticker, OHLCV, Balances } from '../base/types.js';
+import type { Int, Str, OrderBook, Order, Trade, Ticker, OHLCV, Balances, Strings, Tickers } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class whitebit extends whitebitRest {
     describe(): any;
@@ -10,6 +10,7 @@ export default class whitebit extends whitebitRest {
     handleDelta(bookside: any, delta: any): void;
     handleDeltas(bookside: any, deltas: any): void;
     watchTicker(symbol: string, params?: {}): Promise<Ticker>;
+    watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     handleTicker(client: Client, message: any): any;
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleTrades(client: Client, message: any): void;

package/js/src/pro/whitebit.js

@@ -21,6 +21,7 @@ export default class whitebit extends whitebitRest {
                 'watchOrderBook': true,
                 'watchOrders': true,
                 'watchTicker': true,
+                'watchTickers': true,
                 'watchTrades': true,
                 'watchTradesForSymbols': false,
             },
@@ -259,6 +260,36 @@ export default class whitebit extends whitebitRest {
         // every time we want to subscribe to another market we have to "re-subscribe" sending it all again
         return await this.watchMultipleSubscription(messageHash, method, symbol, false, params);
     }
+    async watchTickers(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name whitebit#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.whitebit.com/public/websocket/#market-statistics
+         * @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 method = 'market_subscribe';
+        const url = this.urls['api']['ws'];
+        const id = this.nonce();
+        const messageHashes = [];
+        const args = [];
+        for (let i = 0; i < symbols.length; i++) {
+            const market = this.market(symbols[i]);
+            messageHashes.push('ticker:' + market['symbol']);
+            args.push(market['id']);
+        }
+        const request = {
+            'id': id,
+            'method': method,
+            'params': args,
+        };
+        await this.watchMultiple(url, messageHashes, this.extend(request, params), messageHashes);
+        return this.filterByArray(this.tickers, 'symbol', symbols);
+    }
     handleTicker(client, message) {
         //
         //   {

package/package.json

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