ccxt 4.3.98 → 4.4.2

package/js/src/pro/hyperliquid.js

@@ -163,6 +163,34 @@ export default class hyperliquid extends hyperliquidRest {
         const orderbook = await this.watch(url, messageHash, message, messageHash);
         return orderbook.limit();
     }
+    async unWatchOrderBook(symbol, params = {}) {
+        /**
+         * @method
+         * @name hyperliquid#unWatchOrderBook
+         * @description unWatches information on open orders with bid (buy) and ask (sell) prices, volumes and other data
+         * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
+         * @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
+         */
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        symbol = market['symbol'];
+        const subMessageHash = 'orderbook:' + symbol;
+        const messageHash = 'unsubscribe:' + subMessageHash;
+        const url = this.urls['api']['ws']['public'];
+        const id = this.nonce().toString();
+        const request = {
+            'id': id,
+            'method': 'unsubscribe',
+            'subscription': {
+                'type': 'l2Book',
+                'coin': market['swap'] ? market['base'] : market['id'],
+            },
+        };
+        const message = this.extend(request, params);
+        return await this.watch(url, messageHash, message, messageHash);
+    }
     handleOrderBook(client, message) {
         //
         //     {
@@ -237,6 +265,30 @@ export default class hyperliquid extends hyperliquidRest {
         }
         return this.tickers;
     }
+    async unWatchTickers(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name hyperliquid#unWatchTickers
+         * @description unWatches a price ticker, a statistical calculation with the information calculated over the past 24 hours for all markets of a specific list
+         * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
+         * @param {string[]} symbols unified symbol of the market to fetch the ticker for
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+         */
+        await this.loadMarkets();
+        symbols = this.marketSymbols(symbols, undefined, true);
+        const subMessageHash = 'tickers';
+        const messageHash = 'unsubscribe:' + subMessageHash;
+        const url = this.urls['api']['ws']['public'];
+        const request = {
+            'method': 'unsubscribe',
+            'subscription': {
+                'type': 'webData2',
+                'user': '0x0000000000000000000000000000000000000000',
+            },
+        };
+        return await this.watch(url, messageHash, this.extend(request, params), messageHash);
+    }
     async watchMyTrades(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -406,17 +458,17 @@ export default class hyperliquid extends hyperliquidRest {
         client.resolve(trades, messageHash);
     }
     async watchTrades(symbol, since = undefined, limit = undefined, params = {}) {
-        /**
-         * @method
-         * @name hyperliquid#watchTrades
-         * @description watches information on multiple trades made in a market
-         * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
-         * @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
-         * @param {object} [params] extra parameters specific to the exchange API endpoint
-         * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure}
-         */
+        // s
+        // @method
+        // @name hyperliquid#watchTrades
+        // @description watches information on multiple trades made in a market
+        // @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
+        // @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
+        // @param {object} [params] extra parameters specific to the exchange API endpoint
+        // @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure}
+        //
         await this.loadMarkets();
         const market = this.market(symbol);
         symbol = market['symbol'];
@@ -436,6 +488,32 @@ export default class hyperliquid extends hyperliquidRest {
         }
         return this.filterBySinceLimit(trades, since, limit, 'timestamp', true);
     }
+    async unWatchTrades(symbol, params = {}) {
+        /**
+         * @method
+         * @name hyperliquid#unWatchTrades
+         * @description unWatches information on multiple trades made in a market
+         * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
+         * @param {string} symbol unified market symbol of the market trades were made in
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/#/?id=trade-structure}
+         */
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        symbol = market['symbol'];
+        const subMessageHash = 'trade:' + symbol;
+        const messageHash = 'unsubscribe:' + subMessageHash;
+        const url = this.urls['api']['ws']['public'];
+        const request = {
+            'method': 'unsubscribe',
+            'subscription': {
+                'type': 'trades',
+                'coin': market['swap'] ? market['base'] : market['id'],
+            },
+        };
+        const message = this.extend(request, params);
+        return await this.watch(url, messageHash, message, messageHash);
+    }
     handleTrades(client, message) {
         //
         //     {
@@ -569,6 +647,34 @@ export default class hyperliquid extends hyperliquidRest {
         }
         return this.filterBySinceLimit(ohlcv, since, limit, 0, true);
     }
+    async unWatchOHLCV(symbol, timeframe = '1m', params = {}) {
+        /**
+         * @method
+         * @name hyperliquid#unWatchOHLCV
+         * @description watches historical candlestick data containing the open, high, low, close price, and the volume of a market
+         * @see https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/websocket/subscriptions
+         * @param {string} symbol unified symbol of the market to fetch OHLCV data for
+         * @param {string} timeframe the length of time each candle represents
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
+         */
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        symbol = market['symbol'];
+        const url = this.urls['api']['ws']['public'];
+        const request = {
+            'method': 'unsubscribe',
+            'subscription': {
+                'type': 'candle',
+                'coin': market['swap'] ? market['base'] : market['id'],
+                'interval': timeframe,
+            },
+        };
+        const subMessageHash = 'candles:' + timeframe + ':' + symbol;
+        const messagehash = 'unsubscribe:' + subMessageHash;
+        const message = this.extend(request, params);
+        return await this.watch(url, messagehash, message, messagehash);
+    }
     handleOHLCV(client, message) {
         //
         //     {
@@ -724,7 +830,121 @@ export default class hyperliquid extends hyperliquidRest {
             return false;
         }
     }
+    handleOrderBookUnsubscription(client, subscription) {
+        //
+        //        "subscription":{
+        //           "type":"l2Book",
+        //           "coin":"BTC",
+        //           "nSigFigs":5,
+        //           "mantissa":null
+        //        }
+        //
+        const coin = this.safeString(subscription, 'coin');
+        const marketId = this.coinToMarketId(coin);
+        const symbol = this.safeSymbol(marketId);
+        const subMessageHash = 'orderbook:' + symbol;
+        const messageHash = 'unsubscribe:' + subMessageHash;
+        this.cleanUnsubscription(client, subMessageHash, messageHash);
+        if (symbol in this.orderbooks) {
+            delete this.orderbooks[symbol];
+        }
+    }
+    handleTradesUnsubscription(client, subscription) {
+        //
+        const coin = this.safeString(subscription, 'coin');
+        const marketId = this.coinToMarketId(coin);
+        const symbol = this.safeSymbol(marketId);
+        const subMessageHash = 'trade:' + symbol;
+        const messageHash = 'unsubscribe:' + subMessageHash;
+        this.cleanUnsubscription(client, subMessageHash, messageHash);
+        if (symbol in this.trades) {
+            delete this.trades[symbol];
+        }
+    }
+    handleTickersUnsubscription(client, subscription) {
+        //
+        const subMessageHash = 'tickers';
+        const messageHash = 'unsubscribe:' + subMessageHash;
+        this.cleanUnsubscription(client, subMessageHash, messageHash);
+        const symbols = Object.keys(this.tickers);
+        for (let i = 0; i < symbols.length; i++) {
+            delete this.tickers[symbols[i]];
+        }
+    }
+    handleOHLCVUnsubscription(client, subscription) {
+        const coin = this.safeString(subscription, 'coin');
+        const marketId = this.coinToMarketId(coin);
+        const symbol = this.safeSymbol(marketId);
+        const interval = this.safeString(subscription, 'interval');
+        const timeframe = this.findTimeframe(interval);
+        const subMessageHash = 'candles:' + timeframe + ':' + symbol;
+        const messageHash = 'unsubscribe:' + subMessageHash;
+        this.cleanUnsubscription(client, subMessageHash, messageHash);
+        if (symbol in this.ohlcvs) {
+            if (timeframe in this.ohlcvs[symbol]) {
+                delete this.ohlcvs[symbol][timeframe];
+            }
+        }
+    }
+    handleSubscriptionResponse(client, message) {
+        // {
+        //     "channel":"subscriptionResponse",
+        //     "data":{
+        //        "method":"unsubscribe",
+        //        "subscription":{
+        //           "type":"l2Book",
+        //           "coin":"BTC",
+        //           "nSigFigs":5,
+        //           "mantissa":null
+        //        }
+        //     }
+        // }
+        //
+        //  {
+        //      "channel":"subscriptionResponse",
+        //      "data":{
+        //         "method":"unsubscribe",
+        //         "subscription":{
+        //            "type":"trades",
+        //            "coin":"PURR/USDC"
+        //         }
+        //      }
+        //  }
+        //
+        const data = this.safeDict(message, 'data', {});
+        const method = this.safeString(data, 'method');
+        if (method === 'unsubscribe') {
+            const subscription = this.safeDict(data, 'subscription', {});
+            const type = this.safeString(subscription, 'type');
+            if (type === 'l2Book') {
+                this.handleOrderBookUnsubscription(client, subscription);
+            }
+            else if (type === 'trades') {
+                this.handleTradesUnsubscription(client, subscription);
+            }
+            else if (type === 'webData2') {
+                this.handleTickersUnsubscription(client, subscription);
+            }
+            else if (type === 'candle') {
+                this.handleOHLCVUnsubscription(client, subscription);
+            }
+        }
+    }
     handleMessage(client, message) {
+        //
+        // {
+        //     "channel":"subscriptionResponse",
+        //     "data":{
+        //        "method":"unsubscribe",
+        //        "subscription":{
+        //           "type":"l2Book",
+        //           "coin":"BTC",
+        //           "nSigFigs":5,
+        //           "mantissa":null
+        //        }
+        //     }
+        // }
+        //
         if (this.handleErrorMessage(client, message)) {
             return;
         }
@@ -738,6 +958,7 @@ export default class hyperliquid extends hyperliquidRest {
             'userFills': this.handleMyTrades,
             'webData2': this.handleWsTickers,
             'post': this.handleWsPost,
+            'subscriptionResponse': this.handleSubscriptionResponse,
         };
         const exacMethod = this.safeValue(methods, topic);
         if (exacMethod !== undefined) {

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

@@ -33,7 +33,6 @@ export default class kucoin extends kucoinRest {
     handleBidAsks(bookSide: any, bidAsks: any): void;
     handleOrderBookSubscription(client: Client, message: any, subscription: any): void;
     handleSubscriptionStatus(client: Client, message: any): void;
-    cleanCache(subscription: Dict): void;
     handleSystemStatus(client: Client, message: any): any;
     watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     parseWsOrderStatus(status: any): string;

package/js/src/pro/kucoin.js

@@ -6,7 +6,7 @@
 
 //  ---------------------------------------------------------------------------
 import kucoinRest from '../kucoin.js';
-import { ExchangeError, ArgumentsRequired, UnsubscribeError } from '../base/errors.js';
+import { ExchangeError, ArgumentsRequired } from '../base/errors.js';
 import { ArrayCache, ArrayCacheByTimestamp, ArrayCacheBySymbolById } from '../base/ws/Cache.js';
 //  ---------------------------------------------------------------------------
 export default class kucoin extends kucoinRest {
@@ -538,8 +538,6 @@ export default class kucoin extends kucoinRest {
          * @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}
          */
@@ -926,64 +924,9 @@ export default class kucoin extends kucoinRest {
             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 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/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, Strings, Tickers, OHLCV } from '../base/types.js';
+import type { Int, Str, OrderBook, Order, Trade, Ticker, Balances, Position, Strings, Tickers, OHLCV, Dict } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class kucoinfutures extends kucoinfuturesRest {
     describe(): any;
@@ -8,6 +8,7 @@ export default class kucoinfutures extends kucoinfuturesRest {
     requestId(): any;
     subscribe(url: any, messageHash: any, subscriptionHash: any, subscription: any, params?: {}): Promise<any>;
     subscribeMultiple(url: any, messageHashes: any, topic: any, subscriptionHashes: any, subscriptionArgs: any, params?: {}): Promise<any>;
+    unSubscribeMultiple(url: any, messageHashes: any, topic: any, subscriptionHashes: any, params?: {}, subscription?: Dict): Promise<any>;
     watchTicker(symbol: string, params?: {}): Promise<Ticker>;
     watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     handleTicker(client: Client, message: any): void;
@@ -22,11 +23,15 @@ export default class kucoinfutures extends kucoinfuturesRest {
     handlePosition(client: Client, message: any): void;
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     watchTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    unWatchTrades(symbol: string, params?: {}): Promise<any>;
+    unWatchTradesForSymbols(symbols: string[], params?: {}): Promise<any>;
     handleTrade(client: Client, message: any): any;
     watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     handleOHLCV(client: Client, message: any): void;
     watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     watchOrderBookForSymbols(symbols: string[], limit?: Int, params?: {}): Promise<OrderBook>;
+    unWatchOrderBook(symbol: string, params?: {}): Promise<any>;
+    unWatchOrderBookForSymbols(symbols: string[], params?: {}): Promise<any>;
     handleDelta(orderbook: any, delta: any): void;
     handleDeltas(bookside: any, deltas: any): void;
     handleOrderBook(client: Client, message: any): void;
@@ -48,5 +53,6 @@ export default class kucoinfutures extends kucoinfuturesRest {
     };
     handlePong(client: Client, message: any): any;
     handleErrorMessage(client: Client, message: any): void;
+    handleSubscriptionStatus(client: Client, message: any): void;
     handleMessage(client: Client, message: any): void;
 }

package/js/src/pro/kucoinfutures.js

@@ -178,6 +178,27 @@ export default class kucoinfutures extends kucoinfuturesRest {
         };
         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
@@ -521,7 +542,7 @@ export default class kucoinfutures extends kucoinfuturesRest {
     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
@@ -555,6 +576,49 @@ export default class kucoinfutures extends kucoinfuturesRest {
         }
         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) {
         //
         //    {
@@ -689,6 +753,7 @@ export default class kucoinfutures extends kucoinfuturesRest {
          * @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
@@ -722,6 +787,48 @@ export default class kucoinfutures extends kucoinfuturesRest {
         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');
@@ -1139,6 +1246,36 @@ export default class kucoinfutures extends kucoinfuturesRest {
         }
         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 = {
@@ -1147,6 +1284,7 @@ export default class kucoinfutures extends kucoinfuturesRest {
             'message': this.handleSubject,
             'pong': this.handlePong,
             'error': this.handleErrorMessage,
+            'ack': this.handleSubscriptionStatus,
         };
         const method = this.safeValue(methods, type);
         if (method !== undefined) {