ccxt 4.1.86 → 4.1.88

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

@@ -1,13 +1,13 @@
 import krakenRest from '../kraken.js';
-import { Int, OrderSide, OrderType, Str } from '../base/types.js';
+import type { Int, OrderSide, OrderType, Str, OrderBook, Order, Trade, Ticker, OHLCV } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class kraken extends krakenRest {
     describe(): any;
-    createOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, params?: {}): Promise<any>;
+    createOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, params?: {}): Promise<Order>;
     handleCreateEditOrder(client: any, message: any): void;
-    editOrderWs(id: string, symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, params?: {}): Promise<any>;
+    editOrderWs(id: string, symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, params?: {}): Promise<Order>;
     cancelOrdersWs(ids: string[], symbol?: Str, params?: {}): Promise<any>;
-    cancelOrderWs(id: string, symbol?: Str, params?: {}): Promise<any>;
+    cancelOrderWs(id: string, symbol?: Str, params?: {}): Promise<Order>;
     handleCancelOrder(client: any, message: any): void;
     cancelAllOrdersWs(symbol?: Str, params?: {}): Promise<any>;
     handleCancelAllOrders(client: any, message: any): void;
@@ -16,10 +16,10 @@ export default class kraken extends krakenRest {
     handleOHLCV(client: Client, message: any, subscription: any): void;
     requestId(): any;
     watchPublic(name: any, symbol: any, params?: {}): Promise<any>;
-    watchTicker(symbol: string, params?: {}): Promise<any>;
-    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<any>;
-    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchTicker(symbol: string, params?: {}): Promise<Ticker>;
+    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
+    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     loadMarkets(reload?: boolean, params?: {}): Promise<import("../base/types.js").Dictionary<import("../base/types.js").MarketInterface>>;
     watchHeartbeat(params?: {}): Promise<any>;
     handleHeartbeat(client: Client, message: any): void;
@@ -29,7 +29,7 @@ export default class kraken extends krakenRest {
     handleSystemStatus(client: Client, message: any): any;
     authenticate(params?: {}): Promise<string>;
     watchPrivate(name: any, symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleMyTrades(client: Client, message: any, subscription?: any): void;
     parseWsTrade(trade: any, market?: any): {
         id: string;
@@ -46,9 +46,9 @@ export default class kraken extends krakenRest {
         cost: any;
         fee: any;
     };
-    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     handleOrders(client: Client, message: any, subscription?: any): void;
-    parseWsOrder(order: any, market?: any): import("../base/types.js").Order;
+    parseWsOrder(order: any, market?: any): Order;
     handleSubscriptionStatus(client: Client, message: any): void;
     handleErrorMessage(client: Client, message: any): boolean;
     handleMessage(client: Client, message: any): any;

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

@@ -1,34 +1,34 @@
 import krakenfuturesRest from '../krakenfutures.js';
-import { Int, Str, Strings } from '../base/types.js';
+import type { Int, Str, Strings, OrderBook, Order, Trade, Ticker, Tickers, Position, Balances } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class krakenfutures extends krakenfuturesRest {
     describe(): any;
     authenticate(params?: {}): Promise<any>;
     subscribePublic(name: string, symbols: string[], params?: {}): Promise<any>;
     subscribePrivate(name: string, messageHash: string, params?: {}): Promise<any>;
-    watchTicker(symbol: string, params?: {}): Promise<any>;
-    watchTickers(symbols?: Strings, params?: {}): Promise<any>;
-    watchTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<any>;
-    watchPositions(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchTicker(symbol: string, params?: {}): Promise<Ticker>;
+    watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
+    watchTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
+    watchPositions(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<Position[]>;
     handlePositions(client: any, message: any): void;
-    parseWsPosition(position: any, market?: any): import("../base/types.js").Position;
-    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    watchBalance(params?: {}): Promise<any>;
+    parseWsPosition(position: any, market?: any): Position;
+    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
+    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    watchBalance(params?: {}): Promise<Balances>;
     handleTrade(client: Client, message: any): any;
-    parseWsTrade(trade: any, market?: any): import("../base/types.js").Trade;
-    parseWsOrderTrade(trade: any, market?: any): import("../base/types.js").Trade;
+    parseWsTrade(trade: any, market?: any): Trade;
+    parseWsOrderTrade(trade: any, market?: any): Trade;
     handleOrder(client: Client, message: any): any;
     handleOrderSnapshot(client: Client, message: any): void;
-    parseWsOrder(order: any, market?: any): import("../base/types.js").Order;
+    parseWsOrder(order: any, market?: any): Order;
     handleTicker(client: Client, message: any): any;
-    parseWsTicker(ticker: any, market?: any): import("../base/types.js").Ticker;
+    parseWsTicker(ticker: any, market?: any): Ticker;
     handleOrderBookSnapshot(client: Client, message: any): void;
     handleOrderBook(client: Client, message: any): void;
     handleBalance(client: Client, message: any): void;
     handleMyTrades(client: Client, message: any): void;
-    parseWsMyTrade(trade: any, market?: any): import("../base/types.js").Trade;
+    parseWsMyTrade(trade: any, market?: any): Trade;
     handleErrorMessage(client: Client, message: any): void;
     handleMessage(client: any, message: any): any;
     handleAuthenticate(client: Client, message: any): any;

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

@@ -1,5 +1,5 @@
 import kucoinRest from '../kucoin.js';
-import { Int, Str, Strings } from '../base/types.js';
+import type { Int, Str, Strings, OrderBook, Order, Trade, Ticker, Tickers, OHLCV, Balances } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class kucoin extends kucoinRest {
     describe(): any;
@@ -7,16 +7,17 @@ export default class kucoin extends kucoinRest {
     negotiateHelper(privateChannel: any, params?: {}): Promise<string>;
     requestId(): any;
     subscribe(url: any, messageHash: any, subscriptionHash: any, params?: {}, subscription?: any): Promise<any>;
-    watchTicker(symbol: string, params?: {}): Promise<any>;
-    watchTickers(symbols?: Strings, params?: {}): Promise<any>;
+    subscribeMultiple(url: any, messageHashes: any, topic: any, subscriptionHashes: any, params?: {}, subscription?: any): Promise<any>;
+    watchTicker(symbol: string, params?: {}): Promise<Ticker>;
+    watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     handleTicker(client: Client, message: any): void;
-    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     handleOHLCV(client: Client, message: any): void;
-    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    watchTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    watchTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleTrade(client: Client, message: any): void;
-    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<any>;
-    watchOrderBookForSymbols(symbols: string[], limit?: Int, params?: {}): Promise<any>;
+    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
+    watchOrderBookForSymbols(symbols: string[], limit?: Int, params?: {}): Promise<OrderBook>;
     handleOrderBook(client: Client, message: any): void;
     getCacheIndex(orderbook: any, cache: any): any;
     handleDelta(orderbook: any, delta: any): void;
@@ -24,14 +25,14 @@ export default class kucoin extends kucoinRest {
     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<any>;
+    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     parseWsOrderStatus(status: any): string;
-    parseWsOrder(order: any, market?: any): import("../base/types.js").Order;
+    parseWsOrder(order: any, market?: any): Order;
     handleOrder(client: Client, message: any): void;
-    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleMyTrade(client: Client, message: any): void;
-    parseWsTrade(trade: any, market?: any): import("../base/types.js").Trade;
-    watchBalance(params?: {}): Promise<any>;
+    parseWsTrade(trade: any, market?: any): Trade;
+    watchBalance(params?: {}): Promise<Balances>;
     handleBalance(client: Client, message: any): void;
     handleSubject(client: Client, message: any): any;
     ping(client: any): {

package/js/src/pro/kucoin.js

@@ -124,6 +124,24 @@ export default class kucoin extends kucoinRest {
         }
         return await this.watch(url, messageHash, message, subscriptionHash, subscription);
     }
+    async subscribeMultiple(url, messageHashes, topic, subscriptionHashes, params = {}, subscription = undefined) {
+        const requestId = this.requestId().toString();
+        const request = {
+            'id': requestId,
+            'type': 'subscribe',
+            'topic': topic,
+            'response': true,
+        };
+        const message = this.extend(request, params);
+        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
@@ -336,17 +354,7 @@ export default class kucoin extends kucoinRest {
          * @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();
-        const url = await this.negotiate(false);
-        const market = this.market(symbol);
-        symbol = market['symbol'];
-        const topic = '/market/match:' + market['id'];
-        const messageHash = 'trades:' + symbol;
-        const trades = await this.subscribe(url, messageHash, topic, params);
-        if (this.newUpdates) {
-            limit = trades.getLimit(symbol, limit);
-        }
-        return this.filterBySinceLimit(trades, since, limit, 'timestamp', true);
+        return await this.watchTradesForSymbols([symbol], since, limit, params);
     }
     async watchTradesForSymbols(symbols, since = undefined, limit = undefined, params = {}) {
         /**
@@ -365,12 +373,18 @@ export default class kucoin extends kucoinRest {
         }
         await this.loadMarkets();
         symbols = this.marketSymbols(symbols);
-        const url = await this.negotiate(false);
-        symbols = this.marketSymbols(symbols);
         const marketIds = this.marketIds(symbols);
+        const url = await this.negotiate(false);
+        const messageHashes = [];
+        const subscriptionHashes = [];
         const topic = '/market/match:' + marketIds.join(',');
-        const messageHash = 'multipleTrades::' + symbols.join(',');
-        const trades = await this.subscribe(url, messageHash, topic, params);
+        for (let i = 0; i < symbols.length; i++) {
+            const symbol = symbols[i];
+            messageHashes.push('trades:' + symbol);
+            const marketId = marketIds[i];
+            subscriptionHashes.push('/market/match:' + marketId);
+        }
+        const trades = await this.subscribeMultiple(url, messageHashes, topic, subscriptionHashes, params);
         if (this.newUpdates) {
             const first = this.safeValue(trades, 0);
             const tradeSymbol = this.safeString(first, 'symbol');
@@ -410,8 +424,6 @@ export default class kucoin extends kucoinRest {
         }
         trades.append(trade);
         client.resolve(trades, messageHash);
-        // watchMultipleTrades
-        this.resolvePromiseIfMessagehashMatches(client, 'multipleTrades::', symbol, trades);
     }
     async watchOrderBook(symbol, limit = undefined, params = {}) {
         /**
@@ -438,24 +450,7 @@ export default class kucoin extends kucoinRest {
         // If the size=0, update the sequence and remove the price of which the
         // size is 0 out of level 2. Fr other cases, please update the price.
         //
-        if (limit !== undefined) {
-            if ((limit !== 20) && (limit !== 100)) {
-                throw new ExchangeError(this.id + " watchOrderBook 'limit' argument must be undefined, 20 or 100");
-            }
-        }
-        await this.loadMarkets();
-        const url = await this.negotiate(false);
-        const market = this.market(symbol);
-        symbol = market['symbol'];
-        const topic = '/market/level2:' + market['id'];
-        const messageHash = 'orderbook:' + symbol;
-        const subscription = {
-            'method': this.handleOrderBookSubscription,
-            'symbol': symbol,
-            'limit': limit,
-        };
-        const orderbook = await this.subscribe(url, messageHash, topic, params, subscription);
-        return orderbook.limit();
+        return await this.watchOrderBookForSymbols([symbol], limit, params);
     }
     async watchOrderBookForSymbols(symbols, limit = undefined, params = {}) {
         /**
@@ -481,13 +476,20 @@ export default class kucoin extends kucoinRest {
         const marketIds = this.marketIds(symbols);
         const url = await this.negotiate(false);
         const topic = '/market/level2:' + marketIds.join(',');
-        const messageHash = 'multipleOrderbook::' + symbols.join(',');
+        const messageHashes = [];
+        const subscriptionHashes = [];
+        for (let i = 0; i < symbols.length; i++) {
+            const symbol = symbols[i];
+            messageHashes.push('orderbook:' + symbol);
+            const marketId = marketIds[i];
+            subscriptionHashes.push('/market/level2:' + marketId);
+        }
         const subscription = {
             'method': this.handleOrderBookSubscription,
             'symbols': symbols,
             'limit': limit,
         };
-        const orderbook = await this.subscribe(url, messageHash, topic, params, subscription);
+        const orderbook = await this.subscribeMultiple(url, messageHashes, topic, subscriptionHashes, params, subscription);
         return orderbook.limit();
     }
     handleOrderBook(client, message) {
@@ -545,8 +547,6 @@ export default class kucoin extends kucoinRest {
         }
         this.handleDelta(storedOrderBook, data);
         client.resolve(storedOrderBook, messageHash);
-        // watchMultipleOrderBook
-        this.resolvePromiseIfMessagehashMatches(client, 'multipleOrderbook::', symbol, storedOrderBook);
     }
     getCacheIndex(orderbook, cache) {
         const firstDelta = this.safeValue(cache, 0);

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

@@ -1,5 +1,5 @@
 import kucoinfuturesRest from '../kucoinfutures.js';
-import { Int, Str } from '../base/types.js';
+import type { Int, Str, OrderBook, Order, Trade, Ticker, Balances, Position } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class kucoinfutures extends kucoinfuturesRest {
     describe(): any;
@@ -7,30 +7,31 @@ 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>;
-    watchTicker(symbol: string, params?: {}): Promise<any>;
+    subscribeMultiple(url: any, messageHashes: any, topic: any, subscriptionHashes: any, subscription: any, params?: {}): Promise<any>;
+    watchTicker(symbol: string, params?: {}): Promise<Ticker>;
     handleTicker(client: Client, message: any): any;
-    watchPosition(symbol?: Str, params?: {}): Promise<any>;
+    watchPosition(symbol?: Str, params?: {}): Promise<Position>;
     getCurrentPosition(symbol: any): any;
     setPositionCache(client: Client, symbol: string): void;
     loadPositionSnapshot(client: any, messageHash: any, symbol: any): Promise<void>;
     handlePosition(client: Client, message: any): void;
-    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    watchTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    watchTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleTrade(client: Client, message: any): any;
-    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<any>;
-    watchOrderBookForSymbols(symbols: string[], limit?: Int, params?: {}): Promise<any>;
+    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
+    watchOrderBookForSymbols(symbols: string[], limit?: Int, params?: {}): Promise<OrderBook>;
     handleDelta(orderbook: any, delta: any): void;
     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): any;
+    handleSubscriptionStatus(client: Client, message: any): void;
     handleSystemStatus(client: Client, message: any): any;
-    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     parseWsOrderStatus(status: any): string;
-    parseWsOrder(order: any, market?: any): import("../base/types.js").Order;
+    parseWsOrder(order: any, market?: any): Order;
     handleOrder(client: Client, message: any): void;
-    watchBalance(params?: {}): Promise<any>;
+    watchBalance(params?: {}): Promise<Balances>;
     handleBalance(client: Client, message: any): void;
     handleBalanceSubscription(client: Client, message: any, subscription: any): void;
     fetchBalanceSnapshot(client: any, message: any): Promise<void>;

package/js/src/pro/kucoinfutures.js

@@ -139,6 +139,26 @@ export default class kucoinfutures extends kucoinfuturesRest {
         }
         return await this.watch(url, messageHash, message, subscriptionHash, subscription);
     }
+    async subscribeMultiple(url, messageHashes, topic, subscriptionHashes, subscription, params = {}) {
+        const requestId = this.requestId().toString();
+        const request = {
+            'id': requestId,
+            'type': 'subscribe',
+            '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);
+    }
     async watchTicker(symbol, params = {}) {
         /**
          * @method
@@ -373,17 +393,7 @@ export default class kucoinfutures extends kucoinfuturesRest {
          * @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();
-        const url = await this.negotiate(false);
-        const market = this.market(symbol);
-        symbol = market['symbol'];
-        const topic = '/contractMarket/execution:' + market['id'];
-        const messageHash = 'trades:' + symbol;
-        const trades = await this.subscribe(url, messageHash, topic, undefined, params);
-        if (this.newUpdates) {
-            limit = trades.getLimit(symbol, limit);
-        }
-        return this.filterBySinceLimit(trades, since, limit, 'timestamp', true);
+        return await this.watchTradesForSymbols([symbol], since, limit, params);
     }
     async watchTradesForSymbols(symbols, since = undefined, limit = undefined, params = {}) {
         /**
@@ -406,8 +416,15 @@ export default class kucoinfutures extends kucoinfuturesRest {
         symbols = this.marketSymbols(symbols);
         const marketIds = this.marketIds(symbols);
         const topic = '/contractMarket/execution:' + marketIds.join(',');
-        const messageHash = 'multipleTrades::' + symbols.join(',');
-        const trades = await this.subscribe(url, messageHash, topic, params);
+        const subscriptionHashes = [];
+        const messageHashes = [];
+        for (let i = 0; i < symbols.length; i++) {
+            const symbol = symbols[i];
+            const marketId = marketIds[i];
+            messageHashes.push('trades:' + symbol);
+            subscriptionHashes.push('/contractMarket/execution:' + marketId);
+        }
+        const trades = await this.subscribeMultiple(url, messageHashes, topic, subscriptionHashes, params);
         if (this.newUpdates) {
             const first = this.safeValue(trades, 0);
             const tradeSymbol = this.safeString(first, 'symbol');
@@ -448,7 +465,6 @@ export default class kucoinfutures extends kucoinfuturesRest {
         trades.append(trade);
         const messageHash = 'trades:' + symbol;
         client.resolve(trades, messageHash);
-        this.resolvePromiseIfMessagehashMatches(client, 'multipleTrades::', symbol, trades);
         return message;
     }
     async watchOrderBook(symbol, limit = undefined, params = {}) {
@@ -468,24 +484,7 @@ export default class kucoinfutures extends kucoinfuturesRest {
          * @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
          */
-        if (limit !== undefined) {
-            if ((limit !== 20) && (limit !== 100)) {
-                throw new ExchangeError(this.id + " watchOrderBook 'limit' argument must be undefined, 20 or 100");
-            }
-        }
-        await this.loadMarkets();
-        const url = await this.negotiate(false);
-        const market = this.market(symbol);
-        symbol = market['symbol'];
-        const topic = '/contractMarket/level2:' + market['id'];
-        const messageHash = 'orderbook:' + symbol;
-        const subscription = {
-            'method': this.handleOrderBookSubscription,
-            'symbol': symbol,
-            'limit': limit,
-        };
-        const orderbook = await this.subscribe(url, messageHash, topic, subscription, params);
-        return orderbook.limit();
+        return await this.watchOrderBookForSymbols([symbol], limit, params);
     }
     async watchOrderBookForSymbols(symbols, limit = undefined, params = {}) {
         /**
@@ -511,13 +510,20 @@ export default class kucoinfutures extends kucoinfuturesRest {
         const marketIds = this.marketIds(symbols);
         const url = await this.negotiate(false);
         const topic = '/contractMarket/level2:' + marketIds.join(',');
-        const messageHash = 'multipleOrderbook::' + symbols.join(',');
         const subscription = {
             'method': this.handleOrderBookSubscription,
             'symbols': symbols,
             'limit': limit,
         };
-        const orderbook = await this.subscribe(url, messageHash, topic, subscription, params);
+        const subscriptionHashes = [];
+        const messageHashes = [];
+        for (let i = 0; i < symbols.length; i++) {
+            const symbol = symbols[i];
+            const marketId = marketIds[i];
+            messageHashes.push('orderbook:' + symbol);
+            subscriptionHashes.push('/contractMarket/level2:' + marketId);
+        }
+        const orderbook = await this.subscribeMultiple(url, messageHashes, topic, subscriptionHashes, subscription, params);
         return orderbook.limit();
     }
     handleDelta(orderbook, delta) {
@@ -598,7 +604,6 @@ export default class kucoinfutures extends kucoinfuturesRest {
         }
         this.handleDelta(storedOrderBook, data);
         client.resolve(storedOrderBook, messageHash);
-        this.resolvePromiseIfMessagehashMatches(client, 'multipleOrderbook::', symbol, storedOrderBook);
     }
     getCacheIndex(orderbook, cache) {
         const firstDelta = this.safeValue(cache, 0);
@@ -648,7 +653,6 @@ export default class kucoinfutures extends kucoinfuturesRest {
         if (method !== undefined) {
             method.call(this, client, message, subscription);
         }
-        return message;
     }
     handleSystemStatus(client, message) {
         //

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

@@ -1,12 +1,12 @@
 import lunoRest from '../luno.js';
-import { Int, Trade } from '../base/types.js';
+import type { Int, Trade, OrderBook } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class luno extends lunoRest {
     describe(): any;
-    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleTrades(client: Client, message: any, subscription: any): void;
     parseTrade(trade: any, market?: any): Trade;
-    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<any>;
+    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     handleOrderBook(client: Client, message: any, subscription: any): void;
     customParseOrderBook(orderbook: any, symbol: any, timestamp?: any, bidsKey?: string, asksKey?: string, priceKey?: string, amountKey?: string, thirdKey?: any): {
         symbol: any;

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

@@ -1,36 +1,36 @@
 import mexcRest from '../mexc.js';
-import { Int, OHLCV, Str } from '../base/types.js';
+import type { Int, OHLCV, Str, OrderBook, Order, Trade, Ticker, Balances } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class mexc extends mexcRest {
     describe(): any;
-    watchTicker(symbol: string, params?: {}): Promise<any>;
+    watchTicker(symbol: string, params?: {}): Promise<Ticker>;
     handleTicker(client: Client, message: any): void;
-    parseWsTicker(ticker: any, market?: any): import("../base/types.js").Ticker;
+    parseWsTicker(ticker: any, market?: any): Ticker;
     watchSpotPublic(channel: any, messageHash: any, params?: {}): Promise<any>;
     watchSpotPrivate(channel: any, messageHash: any, params?: {}): Promise<any>;
     watchSwapPublic(channel: any, messageHash: any, requestParams: any, params?: {}): Promise<any>;
     watchSwapPrivate(messageHash: any, params?: {}): Promise<any>;
-    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     handleOHLCV(client: Client, message: any): void;
     parseWsOHLCV(ohlcv: any, market?: any): OHLCV;
-    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<any>;
+    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     handleOrderBookSubscription(client: Client, message: any): void;
     getCacheIndex(orderbook: any, cache: any): any;
     handleOrderBook(client: Client, message: any): void;
     handleBooksideDelta(bookside: any, bidasks: any): void;
     handleDelta(orderbook: any, delta: any): void;
-    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleTrades(client: Client, message: any): void;
-    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleMyTrade(client: Client, message: any, subscription?: any): void;
-    parseWsTrade(trade: any, market?: any): import("../base/types.js").Trade;
-    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    parseWsTrade(trade: any, market?: any): Trade;
+    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     handleOrder(client: Client, message: any): void;
-    parseWsOrder(order: any, market?: any): import("../base/types.js").Order;
+    parseWsOrder(order: any, market?: any): Order;
     parseWsOrderStatus(status: any, market?: any): string;
     parseWsOrderType(type: any): string;
     parseWsTimeInForce(timeInForce: any): string;
-    watchBalance(params?: {}): Promise<any>;
+    watchBalance(params?: {}): Promise<Balances>;
     handleBalance(client: Client, message: any): void;
     authenticate(subscriptionHash: any, params?: {}): Promise<string>;
     keepAliveListenKey(listenKey: any, params?: {}): Promise<void>;

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

@@ -1,16 +1,16 @@
 import ndaxRest from '../ndax.js';
-import { Int } from '../base/types.js';
+import type { Int, OrderBook, Trade, Ticker, OHLCV } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class ndax extends ndaxRest {
     describe(): any;
     requestId(): any;
-    watchTicker(symbol: string, params?: {}): Promise<any>;
+    watchTicker(symbol: string, params?: {}): Promise<Ticker>;
     handleTicker(client: Client, message: any): void;
-    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleTrades(client: Client, message: any): void;
-    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<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<any>;
+    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     handleOrderBook(client: Client, message: any): any;
     handleOrderBookSubscription(client: Client, message: any, subscription: any): void;
     handleSubscriptionStatus(client: Client, message: any): any;

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

@@ -1,24 +1,24 @@
 import okcoinRest from '../okcoin.js';
-import { Int, Str } from '../base/types.js';
+import type { Int, Str, OrderBook, Order, Trade, Ticker, OHLCV, Balances } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class okcoin extends okcoinRest {
     describe(): any;
     subscribe(channel: any, symbol: any, params?: {}): Promise<any>;
-    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<any>;
-    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
+    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     handleOrders(client: Client, message: any, subscription?: any): void;
-    watchTicker(symbol: string, params?: {}): Promise<any>;
+    watchTicker(symbol: string, params?: {}): Promise<Ticker>;
     handleTrade(client: Client, message: any): any;
     handleTicker(client: Client, message: any): any;
-    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<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<any>;
+    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     handleDelta(bookside: any, delta: any): void;
     handleDeltas(bookside: any, deltas: any): void;
     handleOrderBookMessage(client: Client, message: any, orderbook: any): any;
     handleOrderBook(client: Client, message: any): any;
     authenticate(params?: {}): Promise<any>;
-    watchBalance(params?: {}): Promise<any>;
+    watchBalance(params?: {}): Promise<Balances>;
     subscribeToUserAccount(negotiation: any, params?: {}): Promise<any>;
     handleBalance(client: Client, message: any): void;
     handleSubscriptionStatus(client: Client, message: any): any;