ccxt 4.2.89 → 4.2.91

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

@@ -1,5 +1,5 @@
 import kucoinfuturesRest from '../kucoinfutures.js';
-import type { Int, Str, OrderBook, Order, Trade, Ticker, Balances, Position } from '../base/types.js';
+import type { Int, Str, OrderBook, Order, Trade, Ticker, Balances, Position, Strings, Tickers } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class kucoinfutures extends kucoinfuturesRest {
     describe(): any;
@@ -7,9 +7,14 @@ export default class kucoinfutures extends kucoinfuturesRest {
     negotiateHelper(privateChannel: any, params?: {}): Promise<string>;
     requestId(): any;
     subscribe(url: any, messageHash: any, subscriptionHash: any, subscription: any, params?: {}): Promise<any>;
-    subscribeMultiple(url: any, messageHashes: any, topic: any, subscriptionHashes: any, subscription: any, params?: {}): Promise<any>;
+    subscribeMultiple(url: any, messageHashes: any, topic: any, subscriptionHashes: any, subscriptionArgs: any, params?: {}): Promise<any>;
     watchTicker(symbol: string, params?: {}): Promise<Ticker>;
-    handleTicker(client: Client, message: any): any;
+    watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
+    handleTicker(client: Client, message: any): void;
+    watchBidsAsks(symbols?: Strings, params?: {}): Promise<Tickers>;
+    watchMultiRequest(methodName: any, channelName: string, symbols?: Strings, params?: {}): Promise<any>;
+    handleBidAsk(client: Client, message: any): void;
+    parseWsBidAsk(ticker: any, market?: any): Ticker;
     watchPosition(symbol?: Str, params?: {}): Promise<Position>;
     getCurrentPosition(symbol: any): any;
     setPositionCache(client: Client, symbol: string): void;
@@ -24,8 +29,6 @@ export default class kucoinfutures extends kucoinfuturesRest {
     handleDeltas(bookside: any, deltas: any): void;
     handleOrderBook(client: Client, message: any): void;
     getCacheIndex(orderbook: any, cache: any): any;
-    handleOrderBookSubscription(client: Client, message: any, subscription: any): void;
-    handleSubscriptionStatus(client: Client, message: any): void;
     handleSystemStatus(client: Client, message: any): any;
     watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     parseWsOrderStatus(status: any): string;
@@ -36,6 +39,7 @@ export default class kucoinfutures extends kucoinfuturesRest {
     handleBalanceSubscription(client: Client, message: any, subscription: any): void;
     fetchBalanceSnapshot(client: any, message: any): Promise<void>;
     handleSubject(client: Client, message: any): void;
+    getMessageHash(elementName: string, symbol?: Str): string;
     ping(client: any): {
         id: any;
         type: string;

package/js/src/pro/kucoinfutures.js

@@ -15,6 +15,8 @@ export default class kucoinfutures extends kucoinfuturesRest {
             'has': {
                 'ws': true,
                 'watchTicker': true,
+                'watchTickers': true,
+                'watchBidsAsks': true,
                 'watchTrades': true,
                 'watchOrderBook': true,
                 'watchOrders': true,
@@ -44,9 +46,6 @@ export default class kucoinfutures extends kucoinfuturesRest {
                     'snapshotDelay': 20,
                     'snapshotMaxRetries': 3,
                 },
-                'watchTicker': {
-                    'name': 'contractMarket/tickerV2', // market/ticker
-                },
                 'watchPosition': {
                     'fetchPositionSnapshot': true,
                     'awaitPositionSnapshot': true, // whether to wait for the position snapshot before providing updates
@@ -149,7 +148,7 @@ export default class kucoinfutures extends kucoinfuturesRest {
         }
         return await this.watch(url, messageHash, message, subscriptionHash, subscription);
     }
-    async subscribeMultiple(url, messageHashes, topic, subscriptionHashes, subscription, params = {}) {
+    async subscribeMultiple(url, messageHashes, topic, subscriptionHashes, subscriptionArgs, params = {}) {
         const requestId = this.requestId().toString();
         const request = {
             'id': requestId,
@@ -157,24 +156,14 @@ export default class kucoinfutures extends kucoinfuturesRest {
             'topic': topic,
             'response': true,
         };
-        const message = this.extend(request, params);
-        const subscriptionRequest = {
-            'id': requestId,
-        };
-        if (subscription === undefined) {
-            subscription = subscriptionRequest;
-        }
-        else {
-            subscription = this.extend(subscriptionRequest, subscription);
-        }
-        return await this.watchMultiple(url, messageHashes, message, subscriptionHashes, subscription);
+        return await this.watchMultiple(url, messageHashes, this.extend(request, params), subscriptionHashes, subscriptionArgs);
     }
     async watchTicker(symbol, params = {}) {
         /**
          * @method
          * @name kucoinfutures#watchTicker
          * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
-         * @see https://docs.kucoin.com/futures/#get-real-time-symbol-ticker-v2
+         * @see https://www.kucoin.com/docs/websocket/futures-trading/public-channels/get-ticker
          * @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}
@@ -182,30 +171,48 @@ export default class kucoinfutures extends kucoinfuturesRest {
         await this.loadMarkets();
         const market = this.market(symbol);
         symbol = market['symbol'];
-        const url = await this.negotiate(false);
-        const options = this.safeValue(this.options, 'watchTicker', {});
-        const channel = this.safeString(options, 'name', 'contractMarket/tickerV2');
-        const topic = '/' + channel + ':' + market['id'];
-        const messageHash = 'ticker:' + symbol;
-        return await this.subscribe(url, messageHash, topic, undefined, params);
+        params['callerMethodName'] = 'watchTicker';
+        const tickers = await this.watchTickers([symbol], params);
+        return tickers[symbol];
+    }
+    async watchTickers(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name kucoinfutures#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
+         * @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();
+        const ticker = await this.watchMultiRequest('watchTickers', '/contractMarket/ticker:', symbols, params);
+        if (this.newUpdates) {
+            const tickers = {};
+            tickers[ticker['symbol']] = ticker;
+            return tickers;
+        }
+        return this.filterByArray(this.tickers, 'symbol', symbols);
     }
     handleTicker(client, message) {
         //
-        // market/tickerV2
+        // ticker (v1)
         //
         //    {
-        //        "type": "message",
-        //        "topic": "/contractMarket/tickerV2:ADAUSDTM",
-        //        "subject": "tickerV2",
-        //        "data": {
-        //            "symbol": "ADAUSDTM",
-        //            "sequence": 1668007800439,
-        //            "bestBidSize": 178,
-        //            "bestBidPrice": "0.35959",
-        //            "bestAskPrice": "0.35981",
-        //            "ts": "1668141430037124460",
-        //            "bestAskSize": 134
-        //        }
+        //     "subject": "ticker",
+        //     "topic": "/contractMarket/ticker:XBTUSDM",
+        //     "data": {
+        //         "symbol": "XBTUSDM", //Market of the symbol
+        //         "sequence": 45, //Sequence number which is used to judge the continuity of the pushed messages
+        //         "side": "sell", //Transaction side of the last traded taker order
+        //         "price": "3600.0", //Filled price
+        //         "size": 16, //Filled quantity
+        //         "tradeId": "5c9dcf4170744d6f5a3d32fb", //Order ID
+        //         "bestBidSize": 795, //Best bid size
+        //         "bestBidPrice": "3200.0", //Best bid
+        //         "bestAskPrice": "3600.0", //Best ask size
+        //         "bestAskSize": 284, //Best ask
+        //         "ts": 1553846081210004941 //Filled time - nanosecond
+        //     }
         //    }
         //
         const data = this.safeValue(message, 'data', {});
@@ -213,9 +220,95 @@ export default class kucoinfutures extends kucoinfuturesRest {
         const market = this.safeMarket(marketId, undefined, '-');
         const ticker = this.parseTicker(data, market);
         this.tickers[market['symbol']] = ticker;
-        const messageHash = 'ticker:' + market['symbol'];
-        client.resolve(ticker, messageHash);
-        return message;
+        client.resolve(ticker, this.getMessageHash('ticker', market['symbol']));
+    }
+    async watchBidsAsks(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name kucoinfutures#watchBidsAsks
+         * @see https://www.kucoin.com/docs/websocket/futures-trading/public-channels/get-ticker-v2
+         * @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}
+         */
+        const ticker = await this.watchMultiRequest('watchBidsAsks', '/contractMarket/tickerV2:', symbols, params);
+        if (this.newUpdates) {
+            const tickers = {};
+            tickers[ticker['symbol']] = ticker;
+            return tickers;
+        }
+        return this.filterByArray(this.bidsasks, 'symbol', symbols);
+    }
+    async watchMultiRequest(methodName, channelName, symbols = undefined, params = {}) {
+        await this.loadMarkets();
+        [methodName, params] = this.handleParamString(params, 'callerMethodName', methodName);
+        const isBidsAsks = (methodName === 'watchBidsAsks');
+        symbols = this.marketSymbols(symbols, undefined, false, true, false);
+        const length = symbols.length;
+        if (length > 100) {
+            throw new ArgumentsRequired(this.id + ' ' + methodName + '() accepts a maximum of 100 symbols');
+        }
+        const messageHashes = [];
+        for (let i = 0; i < symbols.length; i++) {
+            const symbol = symbols[i];
+            const market = this.market(symbol);
+            const prefix = isBidsAsks ? 'bidask' : 'ticker';
+            messageHashes.push(this.getMessageHash(prefix, market['symbol']));
+        }
+        const url = await this.negotiate(false);
+        const marketIds = this.marketIds(symbols);
+        const joined = marketIds.join(',');
+        const requestId = this.requestId().toString();
+        const request = {
+            'id': requestId,
+            'type': 'subscribe',
+            'topic': channelName + joined,
+            'response': true,
+        };
+        const subscription = {
+            'id': requestId,
+        };
+        return await this.watchMultiple(url, messageHashes, this.extend(request, params), messageHashes, subscription);
+    }
+    handleBidAsk(client, message) {
+        //
+        // arrives one symbol dict
+        //
+        // {
+        //   "subject": "tickerV2",
+        //   "topic": "/contractMarket/tickerV2:XBTUSDM",
+        //   "data": {
+        //     "symbol": "XBTUSDM", //Market of the symbol
+        //     "bestBidSize": 795, // Best bid size
+        //     "bestBidPrice": 3200.0, // Best bid
+        //     "bestAskPrice": 3600.0, // Best ask
+        //     "bestAskSize": 284, // Best ask size
+        //     "ts": 1553846081210004941 // Filled time - nanosecond
+        //   }
+        // }
+        //
+        const parsedTicker = this.parseWsBidAsk(message);
+        const symbol = parsedTicker['symbol'];
+        this.bidsasks[symbol] = parsedTicker;
+        client.resolve(parsedTicker, this.getMessageHash('bidask', symbol));
+    }
+    parseWsBidAsk(ticker, market = undefined) {
+        const data = this.safeDict(ticker, 'data', {});
+        const marketId = this.safeString(data, 'symbol');
+        market = this.safeMarket(marketId, market);
+        const symbol = this.safeString(market, 'symbol');
+        const timestamp = this.safeIntegerProduct(data, 'ts', 0.000001);
+        return this.safeTicker({
+            'symbol': symbol,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'ask': this.safeNumber(data, 'bestAskPrice'),
+            'askVolume': this.safeNumber(data, 'bestAskSize'),
+            'bid': this.safeNumber(data, 'bestBidPrice'),
+            'bidVolume': this.safeNumber(data, 'bestBidSize'),
+            'info': ticker,
+        }, market);
     }
     async watchPosition(symbol = undefined, params = {}) {
         /**
@@ -434,7 +527,7 @@ export default class kucoinfutures extends kucoinfuturesRest {
             messageHashes.push('trades:' + symbol);
             subscriptionHashes.push('/contractMarket/execution:' + marketId);
         }
-        const trades = await this.subscribeMultiple(url, messageHashes, topic, subscriptionHashes, params);
+        const trades = await this.subscribeMultiple(url, messageHashes, topic, subscriptionHashes, undefined, params);
         if (this.newUpdates) {
             const first = this.safeValue(trades, 0);
             const tradeSymbol = this.safeString(first, 'symbol');
@@ -520,9 +613,7 @@ export default class kucoinfutures extends kucoinfuturesRest {
         const marketIds = this.marketIds(symbols);
         const url = await this.negotiate(false);
         const topic = '/contractMarket/level2:' + marketIds.join(',');
-        const subscription = {
-            'method': this.handleOrderBookSubscription,
-            'symbols': symbols,
+        const subscriptionArgs = {
             'limit': limit,
         };
         const subscriptionHashes = [];
@@ -533,7 +624,7 @@ export default class kucoinfutures extends kucoinfuturesRest {
             messageHashes.push('orderbook:' + symbol);
             subscriptionHashes.push('/contractMarket/level2:' + marketId);
         }
-        const orderbook = await this.subscribeMultiple(url, messageHashes, topic, subscriptionHashes, subscription, params);
+        const orderbook = await this.subscribeMultiple(url, messageHashes, topic, subscriptionHashes, subscriptionArgs, params);
         return orderbook.limit();
     }
     handleDelta(orderbook, delta) {
@@ -584,11 +675,13 @@ export default class kucoinfutures extends kucoinfuturesRest {
         const marketId = this.safeString(topicParts, 1);
         const symbol = this.safeSymbol(marketId, undefined, '-');
         const messageHash = 'orderbook:' + symbol;
-        const storedOrderBook = this.safeValue(this.orderbooks, symbol);
-        const nonce = this.safeInteger(storedOrderBook, 'nonce');
-        if (storedOrderBook === undefined) {
-            return; // this shouldn't be needed, but for some reason sometimes this runs before handleOrderBookSubscription in c#
+        if (!(symbol in this.orderbooks)) {
+            const subscriptionArgs = this.safeDict(client.subscriptions, topic, {});
+            const limit = this.safeInteger(subscriptionArgs, 'limit');
+            this.orderbooks[symbol] = this.orderBook({}, limit);
         }
+        const storedOrderBook = this.orderbooks[symbol];
+        const nonce = this.safeInteger(storedOrderBook, 'nonce');
         const deltaEnd = this.safeInteger(data, 'sequence');
         if (nonce === undefined) {
             const cacheLength = storedOrderBook.cache.length;
@@ -634,39 +727,6 @@ export default class kucoinfutures extends kucoinfuturesRest {
         }
         return cache.length;
     }
-    handleOrderBookSubscription(client, message, subscription) {
-        const limit = this.safeInteger(subscription, 'limit');
-        const symbols = this.safeValue(subscription, 'symbols');
-        if (symbols === undefined) {
-            const symbol = this.safeString(subscription, 'symbol');
-            this.orderbooks[symbol] = this.orderBook({}, limit);
-        }
-        else {
-            for (let i = 0; i < symbols.length; i++) {
-                const symbol = symbols[i];
-                this.orderbooks[symbol] = this.orderBook({}, limit);
-            }
-        }
-        // moved snapshot initialization to handleOrderBook to fix
-        // https://github.com/ccxt/ccxt/issues/6820
-        // the general idea is to fetch the snapshot after the first delta
-        // but not before, because otherwise we cannot synchronize the feed
-    }
-    handleSubscriptionStatus(client, message) {
-        //
-        //     {
-        //         "id": "1578090438322",
-        //         "type": "ack"
-        //     }
-        //
-        const id = this.safeString(message, 'id');
-        const subscriptionsById = this.indexBy(client.subscriptions, 'id');
-        const subscription = this.safeValue(subscriptionsById, id, {});
-        const method = this.safeValue(subscription, 'method');
-        if (method !== undefined) {
-            method.call(this, client, message, subscription);
-        }
-    }
     handleSystemStatus(client, message) {
         //
         // todo: answer the question whether handleSystemStatus should be renamed
@@ -925,7 +985,8 @@ export default class kucoinfutures extends kucoinfuturesRest {
         const subject = this.safeString(message, 'subject');
         const methods = {
             'level2': this.handleOrderBook,
-            'tickerV2': this.handleTicker,
+            'ticker': this.handleTicker,
+            'tickerV2': this.handleBidAsk,
             'availableBalance.change': this.handleBalance,
             'match': this.handleTrade,
             'orderChange': this.handleOrder,
@@ -939,6 +1000,15 @@ export default class kucoinfutures extends kucoinfuturesRest {
             method.call(this, client, message);
         }
     }
+    getMessageHash(elementName, symbol = undefined) {
+        // elementName can be 'ticker', 'bidask', ...
+        if (symbol !== undefined) {
+            return elementName + '@' + symbol;
+        }
+        else {
+            return elementName + 's@all';
+        }
+    }
     ping(client) {
         // kucoin does not support built-in ws protocol-level ping-pong
         // instead it requires a custom json-based text ping-pong
@@ -978,7 +1048,6 @@ export default class kucoinfutures extends kucoinfuturesRest {
         const methods = {
             // 'heartbeat': this.handleHeartbeat,
             'welcome': this.handleSystemStatus,
-            'ack': this.handleSubscriptionStatus,
             'message': this.handleSubject,
             'pong': this.handlePong,
             'error': this.handleErrorMessage,

package/js/src/woo.js

@@ -71,6 +71,7 @@ export default class woo extends Exchange {
                 'fetchIndexOHLCV': false,
                 'fetchLedger': true,
                 'fetchLeverage': true,
+                'fetchMarginAdjustmentHistory': false,
                 'fetchMarginMode': false,
                 'fetchMarkets': true,
                 'fetchMarkOHLCV': false,

package/package.json

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