ccxt 4.4.1 → 4.4.3

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

@@ -14,7 +14,8 @@ class cryptocom extends cryptocom$1 {
                 'ws': true,
                 'watchBalance': true,
                 'watchTicker': true,
-                'watchTickers': false,
+                'watchTickers': true,
+                'watchBidsAsks': true,
                 'watchMyTrades': true,
                 'watchTrades': true,
                 'watchTradesForSymbols': true,
@@ -371,7 +372,7 @@ class cryptocom extends cryptocom$1 {
             messageHashes.push('unsubscribe:trades:' + market['symbol']);
             topics.push(currentTopic);
         }
-        return await this.unWatchPublicMultiple('trade', symbols, messageHashes, topics, topics, params);
+        return await this.unWatchPublicMultiple('trades', symbols, messageHashes, topics, topics, params);
     }
     handleTrades(client, message) {
         //
@@ -477,41 +478,210 @@ class cryptocom extends cryptocom$1 {
         const messageHash = 'unsubscribe:ticker:' + market['symbol'];
         return await this.unWatchPublicMultiple('ticker', [market['symbol']], [messageHash], [subMessageHash], [subMessageHash], params);
     }
+    async watchTickers(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name cryptocom#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://exchange-docs.crypto.com/exchange/v1/rest-ws/index.html#ticker-instrument_name
+         * @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 marketIds = this.marketIds(symbols);
+        for (let i = 0; i < marketIds.length; i++) {
+            const marketId = marketIds[i];
+            messageHashes.push('ticker.' + marketId);
+        }
+        const url = this.urls['api']['ws']['public'];
+        const id = this.nonce();
+        const request = {
+            'method': 'subscribe',
+            'params': {
+                'channels': messageHashes,
+            },
+            'nonce': id,
+        };
+        const ticker = await this.watchMultiple(url, messageHashes, this.extend(request, params), messageHashes);
+        if (this.newUpdates) {
+            const result = {};
+            result[ticker['symbol']] = ticker;
+            return result;
+        }
+        return this.filterByArray(this.tickers, 'symbol', symbols);
+    }
+    async unWatchTickers(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name cryptocom#unWatchTickers
+         * @description unWatches a price ticker
+         * @see https://exchange-docs.crypto.com/exchange/v1/rest-ws/index.html#ticker-instrument_name
+         * @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 subMessageHashes = [];
+        const marketIds = this.marketIds(symbols);
+        for (let i = 0; i < marketIds.length; i++) {
+            const marketId = marketIds[i];
+            const symbol = symbols[i];
+            subMessageHashes.push('ticker.' + marketId);
+            messageHashes.push('unsubscribe:ticker:' + symbol);
+        }
+        return await this.unWatchPublicMultiple('ticker', symbols, messageHashes, subMessageHashes, subMessageHashes, params);
+    }
     handleTicker(client, message) {
         //
-        // {
-        //     "info":{
-        //        "instrument_name":"BTC_USDT",
-        //        "subscription":"ticker.BTC_USDT",
-        //        "channel":"ticker",
-        //        "data":[
-        //           {
-        //              "i":"BTC_USDT",
-        //              "b":43063.19,
-        //              "k":43063.2,
-        //              "a":43063.19,
-        //              "t":1648121165658,
-        //              "v":43573.912409,
-        //              "h":43498.51,
-        //              "l":41876.58,
-        //              "c":1087.43
-        //           }
-        //        ]
+        //     {
+        //       "instrument_name": "ETHUSD-PERP",
+        //       "subscription": "ticker.ETHUSD-PERP",
+        //       "channel": "ticker",
+        //       "data": [
+        //         {
+        //           "h": "2400.20",
+        //           "l": "2277.10",
+        //           "a": "2335.25",
+        //           "c": "-0.0022",
+        //           "b": "2335.10",
+        //           "bs": "5.4000",
+        //           "k": "2335.16",
+        //           "ks": "1.9970",
+        //           "i": "ETHUSD-PERP",
+        //           "v": "1305697.6462",
+        //           "vv": "3058704939.17",
+        //           "oi": "161646.3614",
+        //           "t": 1726069647560
+        //         }
+        //       ]
         //     }
-        //  }
         //
+        this.handleBidAsk(client, message);
         const messageHash = this.safeString(message, 'subscription');
         const marketId = this.safeString(message, 'instrument_name');
         const market = this.safeMarket(marketId);
         const data = this.safeValue(message, 'data', []);
         for (let i = 0; i < data.length; i++) {
             const ticker = data[i];
-            const parsed = this.parseTicker(ticker, market);
+            const parsed = this.parseWsTicker(ticker, market);
             const symbol = parsed['symbol'];
             this.tickers[symbol] = parsed;
             client.resolve(parsed, messageHash);
         }
     }
+    parseWsTicker(ticker, market = undefined) {
+        //
+        //     {
+        //       "h": "2400.20",
+        //       "l": "2277.10",
+        //       "a": "2335.25",
+        //       "c": "-0.0022",
+        //       "b": "2335.10",
+        //       "bs": "5.4000",
+        //       "k": "2335.16",
+        //       "ks": "1.9970",
+        //       "i": "ETHUSD-PERP",
+        //       "v": "1305697.6462",
+        //       "vv": "3058704939.17",
+        //       "oi": "161646.3614",
+        //       "t": 1726069647560
+        //     }
+        //
+        const timestamp = this.safeInteger(ticker, 't');
+        const marketId = this.safeString(ticker, 'i');
+        market = this.safeMarket(marketId, market, '_');
+        const quote = this.safeString(market, 'quote');
+        const last = this.safeString(ticker, 'a');
+        return this.safeTicker({
+            'symbol': market['symbol'],
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'high': this.safeNumber(ticker, 'h'),
+            'low': this.safeNumber(ticker, 'l'),
+            'bid': this.safeNumber(ticker, 'b'),
+            'bidVolume': this.safeNumber(ticker, 'bs'),
+            'ask': this.safeNumber(ticker, 'k'),
+            'askVolume': this.safeNumber(ticker, 'ks'),
+            'vwap': undefined,
+            'open': undefined,
+            'close': last,
+            'last': last,
+            'previousClose': undefined,
+            'change': undefined,
+            'percentage': this.safeString(ticker, 'c'),
+            'average': undefined,
+            'baseVolume': this.safeString(ticker, 'v'),
+            'quoteVolume': (quote === 'USD') ? this.safeString(ticker, 'vv') : undefined,
+            'info': ticker,
+        }, market);
+    }
+    async watchBidsAsks(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name cryptocom#watchBidsAsks
+         * @see https://exchange-docs.crypto.com/exchange/v1/rest-ws/index.html#ticker-instrument_name
+         * @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, false);
+        const messageHashes = [];
+        const topics = [];
+        const marketIds = this.marketIds(symbols);
+        for (let i = 0; i < marketIds.length; i++) {
+            const marketId = marketIds[i];
+            messageHashes.push('bidask.' + symbols[i]);
+            topics.push('ticker.' + marketId);
+        }
+        const url = this.urls['api']['ws']['public'];
+        const id = this.nonce();
+        const request = {
+            'method': 'subscribe',
+            'params': {
+                'channels': topics,
+            },
+            'nonce': id,
+        };
+        const newTickers = await this.watchMultiple(url, messageHashes, this.extend(request, params), messageHashes);
+        if (this.newUpdates) {
+            const tickers = {};
+            tickers[newTickers['symbol']] = newTickers;
+            return tickers;
+        }
+        return this.filterByArray(this.bidsasks, 'symbol', symbols);
+    }
+    handleBidAsk(client, message) {
+        const data = this.safeList(message, 'data', []);
+        const ticker = this.safeDict(data, 0, {});
+        const parsedTicker = this.parseWsBidAsk(ticker);
+        const symbol = parsedTicker['symbol'];
+        this.bidsasks[symbol] = parsedTicker;
+        const messageHash = 'bidask.' + symbol;
+        client.resolve(parsedTicker, messageHash);
+    }
+    parseWsBidAsk(ticker, market = undefined) {
+        const marketId = this.safeString(ticker, 'i');
+        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.safeString(ticker, 'k'),
+            'askVolume': this.safeString(ticker, 'ks'),
+            'bid': this.safeString(ticker, 'b'),
+            'bidVolume': this.safeString(ticker, 'bs'),
+            'info': ticker,
+        }, market);
+    }
     async watchOHLCV(symbol, timeframe = '1m', since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -1205,50 +1375,12 @@ class cryptocom extends cryptocom$1 {
                 for (let j = 0; j < messageHashes.length; j++) {
                     const unsubHash = messageHashes[j];
                     const subHash = subMessageHashes[j];
-                    if (unsubHash in client.subscriptions) {
-                        delete client.subscriptions[unsubHash];
-                    }
-                    if (subHash in client.subscriptions) {
-                        delete client.subscriptions[subHash];
-                    }
-                    const error = new errors.UnsubscribeError(this.id + ' ' + subHash);
-                    client.reject(error, subHash);
-                    client.resolve(true, unsubHash);
+                    this.cleanUnsubscription(client, subHash, unsubHash);
                 }
                 this.cleanCache(subscription);
             }
         }
     }
-    cleanCache(subscription) {
-        const topic = this.safeString(subscription, 'topic');
-        const symbols = this.safeList(subscription, 'symbols', []);
-        const symbolsLength = symbols.length;
-        if (topic === 'ohlcv') {
-            const symbolsAndTimeFrames = this.safeList(subscription, 'symbolsAndTimeframes', []);
-            for (let i = 0; i < symbolsAndTimeFrames.length; i++) {
-                const symbolAndTimeFrame = symbolsAndTimeFrames[i];
-                const symbol = this.safeString(symbolAndTimeFrame, 0);
-                const timeframe = this.safeString(symbolAndTimeFrame, 1);
-                if (timeframe in this.ohlcvs[symbol]) {
-                    delete this.ohlcvs[symbol][timeframe];
-                }
-            }
-        }
-        else if (symbolsLength > 0) {
-            for (let i = 0; i < symbols.length; i++) {
-                const symbol = symbols[i];
-                if (topic === 'trade') {
-                    delete this.trades[symbol];
-                }
-                else if (topic === 'orderbook') {
-                    delete this.orderbooks[symbol];
-                }
-                else if (topic === 'ticker') {
-                    delete this.tickers[symbol];
-                }
-            }
-        }
-    }
 }
 
 module.exports = cryptocom;

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

@@ -1660,15 +1660,7 @@ class gate extends gate$1 {
                 for (let j = 0; j < messageHashes.length; j++) {
                     const unsubHash = messageHashes[j];
                     const subHash = subMessageHashes[j];
-                    if (unsubHash in client.subscriptions) {
-                        delete client.subscriptions[unsubHash];
-                    }
-                    if (subHash in client.subscriptions) {
-                        delete client.subscriptions[subHash];
-                    }
-                    const error = new errors.UnsubscribeError(this.id + ' ' + messageHash);
-                    client.reject(error, subHash);
-                    client.resolve(true, unsubHash);
+                    this.cleanUnsubscription(client, subHash, unsubHash);
                 }
                 this.cleanCache(subscription);
             }

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

@@ -841,15 +841,7 @@ class hyperliquid extends hyperliquid$1 {
         const symbol = this.safeSymbol(marketId);
         const subMessageHash = 'orderbook:' + symbol;
         const messageHash = 'unsubscribe:' + subMessageHash;
-        if (messageHash in client.subscriptions) {
-            delete client.subscriptions[messageHash];
-        }
-        if (subMessageHash in client.subscriptions) {
-            delete client.subscriptions[subMessageHash];
-        }
-        const error = new errors.UnsubscribeError(this.id + ' ' + subMessageHash);
-        client.reject(error, subMessageHash);
-        client.resolve(true, messageHash);
+        this.cleanUnsubscription(client, subMessageHash, messageHash);
         if (symbol in this.orderbooks) {
             delete this.orderbooks[symbol];
         }
@@ -861,15 +853,7 @@ class hyperliquid extends hyperliquid$1 {
         const symbol = this.safeSymbol(marketId);
         const subMessageHash = 'trade:' + symbol;
         const messageHash = 'unsubscribe:' + subMessageHash;
-        if (messageHash in client.subscriptions) {
-            delete client.subscriptions[messageHash];
-        }
-        if (subMessageHash in client.subscriptions) {
-            delete client.subscriptions[subMessageHash];
-        }
-        const error = new errors.UnsubscribeError(this.id + ' ' + subMessageHash);
-        client.reject(error, subMessageHash);
-        client.resolve(true, messageHash);
+        this.cleanUnsubscription(client, subMessageHash, messageHash);
         if (symbol in this.trades) {
             delete this.trades[symbol];
         }
@@ -878,15 +862,7 @@ class hyperliquid extends hyperliquid$1 {
         //
         const subMessageHash = 'tickers';
         const messageHash = 'unsubscribe:' + subMessageHash;
-        if (messageHash in client.subscriptions) {
-            delete client.subscriptions[messageHash];
-        }
-        if (subMessageHash in client.subscriptions) {
-            delete client.subscriptions[subMessageHash];
-        }
-        const error = new errors.UnsubscribeError(this.id + ' ' + subMessageHash);
-        client.reject(error, subMessageHash);
-        client.resolve(true, messageHash);
+        this.cleanUnsubscription(client, subMessageHash, messageHash);
         const symbols = Object.keys(this.tickers);
         for (let i = 0; i < symbols.length; i++) {
             delete this.tickers[symbols[i]];
@@ -900,15 +876,7 @@ class hyperliquid extends hyperliquid$1 {
         const timeframe = this.findTimeframe(interval);
         const subMessageHash = 'candles:' + timeframe + ':' + symbol;
         const messageHash = 'unsubscribe:' + subMessageHash;
-        if (messageHash in client.subscriptions) {
-            delete client.subscriptions[messageHash];
-        }
-        if (subMessageHash in client.subscriptions) {
-            delete client.subscriptions[subMessageHash];
-        }
-        const error = new errors.UnsubscribeError(this.id + ' ' + subMessageHash);
-        client.reject(error, subMessageHash);
-        client.resolve(true, messageHash);
+        this.cleanUnsubscription(client, subMessageHash, messageHash);
         if (symbol in this.ohlcvs) {
             if (timeframe in this.ohlcvs[symbol]) {
                 delete this.ohlcvs[symbol][timeframe];

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

@@ -535,8 +535,6 @@ class kucoin extends kucoin$1 {
          * @description unWatches trades stream
          * @see https://www.kucoin.com/docs/websocket/spot-trading/public-channels/match-execution-data
          * @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
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades}
          */
@@ -923,64 +921,9 @@ class kucoin extends kucoin$1 {
             for (let i = 0; i < messageHashes.length; i++) {
                 const messageHash = messageHashes[i];
                 const subHash = subMessageHashes[i];
-                if (messageHash in client.subscriptions) {
-                    delete client.subscriptions[messageHash];
-                }
-                if (subHash in client.subscriptions) {
-                    delete client.subscriptions[subHash];
-                }
-                const error = new errors.UnsubscribeError(this.id + ' ' + subHash);
-                client.reject(error, subHash);
-                client.resolve(true, messageHash);
-                this.cleanCache(subscription);
-            }
-        }
-    }
-    cleanCache(subscription) {
-        const topic = this.safeString(subscription, 'topic');
-        const symbols = this.safeList(subscription, 'symbols', []);
-        const symbolsLength = symbols.length;
-        if (symbolsLength > 0) {
-            for (let i = 0; i < symbols.length; i++) {
-                const symbol = symbols[i];
-                if (topic === 'trades') {
-                    if (symbol in this.trades) {
-                        delete this.trades[symbol];
-                    }
-                }
-                else if (topic === 'orderbook') {
-                    if (symbol in this.orderbooks) {
-                        delete this.orderbooks[symbol];
-                    }
-                }
-                else if (topic === 'ticker') {
-                    if (symbol in this.tickers) {
-                        delete this.tickers[symbol];
-                    }
-                }
-            }
-        }
-        else {
-            if (topic === 'myTrades') {
-                // don't reset this.myTrades directly here
-                // because in c# we need to use a different object
-                const keys = Object.keys(this.myTrades);
-                for (let i = 0; i < keys.length; i++) {
-                    delete this.myTrades[keys[i]];
-                }
-            }
-            else if (topic === 'orders') {
-                const orderSymbols = Object.keys(this.orders);
-                for (let i = 0; i < orderSymbols.length; i++) {
-                    delete this.orders[orderSymbols[i]];
-                }
-            }
-            else if (topic === 'ticker') {
-                const tickerSymbols = Object.keys(this.tickers);
-                for (let i = 0; i < tickerSymbols.length; i++) {
-                    delete this.tickers[tickerSymbols[i]];
-                }
+                this.cleanUnsubscription(client, subHash, messageHash);
             }
+            this.cleanCache(subscription);
         }
     }
     handleSystemStatus(client, message) {

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

@@ -175,6 +175,27 @@ class kucoinfutures extends kucoinfutures$1 {
         };
         return await this.watchMultiple(url, messageHashes, this.extend(request, params), subscriptionHashes, subscriptionArgs);
     }
+    async unSubscribeMultiple(url, messageHashes, topic, subscriptionHashes, params = {}, subscription = undefined) {
+        const requestId = this.requestId().toString();
+        const request = {
+            'id': requestId,
+            'type': 'unsubscribe',
+            'topic': topic,
+            'response': true,
+        };
+        const message = this.extend(request, params);
+        if (subscription !== undefined) {
+            subscription[requestId] = requestId;
+        }
+        const client = this.client(url);
+        for (let i = 0; i < subscriptionHashes.length; i++) {
+            const subscriptionHash = subscriptionHashes[i];
+            if (!(subscriptionHash in client.subscriptions)) {
+                client.subscriptions[requestId] = subscriptionHash;
+            }
+        }
+        return await this.watchMultiple(url, messageHashes, message, subscriptionHashes, subscription);
+    }
     async watchTicker(symbol, params = {}) {
         /**
          * @method
@@ -518,7 +539,7 @@ class kucoinfutures extends kucoinfutures$1 {
     async watchTradesForSymbols(symbols, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
-         * @name kucoinfutures#watchTrades
+         * @name kucoinfutures#watchTradesForSymbols
          * @description get the list of most recent trades for a particular symbol
          * @param {string} symbol unified symbol of the market to fetch trades for
          * @param {int} [since] timestamp in ms of the earliest trade to fetch
@@ -552,6 +573,49 @@ class kucoinfutures extends kucoinfutures$1 {
         }
         return this.filterBySinceLimit(trades, since, limit, 'timestamp', true);
     }
+    async unWatchTrades(symbol, params = {}) {
+        /**
+         * @method
+         * @name kucoinfutures#unWatchTrades
+         * @description unWatches trades stream
+         * @see https://docs.kucoin.com/futures/#execution-data
+         * @param {string} symbol unified symbol of the market to fetch trades for
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades}
+         */
+        return await this.unWatchTradesForSymbols([symbol], params);
+    }
+    async unWatchTradesForSymbols(symbols, params = {}) {
+        /**
+         * @method
+         * @name kucoinfutures#unWatchTradesForSymbols
+         * @description get the list of most recent trades for a particular symbol
+         * @param {string} symbol unified symbol of the market to fetch trades for
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=public-trades}
+         */
+        await this.loadMarkets();
+        symbols = this.marketSymbols(symbols, undefined, false);
+        const url = await this.negotiate(false);
+        symbols = this.marketSymbols(symbols);
+        const marketIds = this.marketIds(symbols);
+        const topic = '/contractMarket/execution:' + marketIds.join(',');
+        const subscriptionHashes = [];
+        const messageHashes = [];
+        for (let i = 0; i < symbols.length; i++) {
+            const symbol = symbols[i];
+            messageHashes.push('unsubscribe:trades:' + symbol);
+            subscriptionHashes.push('trades:' + symbol);
+        }
+        const subscription = {
+            'messageHashes': messageHashes,
+            'subMessageHashes': subscriptionHashes,
+            'topic': 'trades',
+            'unsubscribe': true,
+            'symbols': symbols,
+        };
+        return await this.unSubscribeMultiple(url, messageHashes, topic, messageHashes, params, subscription);
+    }
     handleTrade(client, message) {
         //
         //    {
@@ -686,6 +750,7 @@ class kucoinfutures extends kucoinfutures$1 {
          * @method
          * @name kucoinfutures#watchOrderBookForSymbols
          * @description watches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
+         * @see https://docs.kucoin.com/futures/#level-2-market-data
          * @param {string[]} symbols unified array of symbols
          * @param {int} [limit] the maximum amount of order book entries to return
          * @param {object} [params] extra parameters specific to the exchange API endpoint
@@ -719,6 +784,48 @@ class kucoinfutures extends kucoinfutures$1 {
         const orderbook = await this.subscribeMultiple(url, messageHashes, topic, subscriptionHashes, subscriptionArgs, params);
         return orderbook.limit();
     }
+    async unWatchOrderBook(symbol, params = {}) {
+        /**
+         * @method
+         * @name kucoinfutures#unWatchOrderBook
+         * @description unWatches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
+         * @see https://docs.kucoin.com/futures/#level-2-market-data
+         * @param {string} symbol unified symbol of the market to fetch the order book for
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
+         */
+        return await this.unWatchOrderBookForSymbols([symbol], params);
+    }
+    async unWatchOrderBookForSymbols(symbols, params = {}) {
+        /**
+         * @method
+         * @name kucoinfutures#unWatchOrderBookForSymbols
+         * @description unWatches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
+         * @param {string[]} symbols unified array of symbols
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} A dictionary of [order book structures]{@link https://docs.ccxt.com/#/?id=order-book-structure} indexed by market symbols
+         */
+        await this.loadMarkets();
+        symbols = this.marketSymbols(symbols);
+        const marketIds = this.marketIds(symbols);
+        const url = await this.negotiate(false);
+        const topic = '/contractMarket/level2:' + marketIds.join(',');
+        const subscriptionHashes = [];
+        const messageHashes = [];
+        for (let i = 0; i < symbols.length; i++) {
+            const symbol = symbols[i];
+            messageHashes.push('unsubscribe:orderbook:' + symbol);
+            subscriptionHashes.push('orderbook:' + symbol);
+        }
+        const subscription = {
+            'messageHashes': messageHashes,
+            'symbols': symbols,
+            'unsubscribe': true,
+            'topic': 'orderbook',
+            'subMessageHashes': subscriptionHashes,
+        };
+        return await this.unSubscribeMultiple(url, messageHashes, topic, messageHashes, params, subscription);
+    }
     handleDelta(orderbook, delta) {
         orderbook['nonce'] = this.safeInteger(delta, 'sequence');
         const timestamp = this.safeInteger(delta, 'timestamp');
@@ -1136,6 +1243,36 @@ class kucoinfutures extends kucoinfutures$1 {
         }
         this.handleErrors(undefined, undefined, client.url, undefined, undefined, data, message, undefined, undefined);
     }
+    handleSubscriptionStatus(client, message) {
+        //
+        //     {
+        //         "id": "1578090438322",
+        //         "type": "ack"
+        //     }
+        //
+        const id = this.safeString(message, 'id');
+        if (!(id in client.subscriptions)) {
+            return;
+        }
+        const subscriptionHash = this.safeString(client.subscriptions, id);
+        const subscription = this.safeValue(client.subscriptions, subscriptionHash);
+        delete client.subscriptions[id];
+        const method = this.safeValue(subscription, 'method');
+        if (method !== undefined) {
+            method.call(this, client, message, subscription);
+        }
+        const isUnSub = this.safeBool(subscription, 'unsubscribe', false);
+        if (isUnSub) {
+            const messageHashes = this.safeList(subscription, 'messageHashes', []);
+            const subMessageHashes = this.safeList(subscription, 'subMessageHashes', []);
+            for (let i = 0; i < messageHashes.length; i++) {
+                const messageHash = messageHashes[i];
+                const subHash = subMessageHashes[i];
+                this.cleanUnsubscription(client, subHash, messageHash);
+            }
+            this.cleanCache(subscription);
+        }
+    }
     handleMessage(client, message) {
         const type = this.safeString(message, 'type');
         const methods = {
@@ -1144,6 +1281,7 @@ class kucoinfutures extends kucoinfutures$1 {
             'message': this.handleSubject,
             'pong': this.handlePong,
             'error': this.handleErrorMessage,
+            'ack': this.handleSubscriptionStatus,
         };
         const method = this.safeValue(methods, type);
         if (method !== undefined) {