ccxt 4.2.31 → 4.2.34

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

@@ -46,7 +46,7 @@ export default class cex extends cexRest {
     resolveData(client: Client, message: any): void;
     handleConnected(client: Client, message: any): any;
     handleErrorMessage(client: Client, message: any): void;
-    handleMessage(client: Client, message: any): any;
+    handleMessage(client: Client, message: any): void;
     handleAuthenticationMessage(client: Client, message: any): void;
     authenticate(params?: {}): Promise<any>;
 }

package/js/src/pro/cex.js

@@ -963,15 +963,15 @@ export default class cex extends cexRest {
         const messageHash = 'orderbook:' + symbol;
         const timestamp = this.safeInteger2(data, 'timestamp_ms', 'timestamp');
         const incrementalId = this.safeNumber(data, 'id');
-        const storedOrderBook = this.orderBook({});
+        const orderbook = this.orderBook({});
         const snapshot = this.parseOrderBook(data, symbol, timestamp, 'bids', 'asks');
         snapshot['nonce'] = incrementalId;
-        storedOrderBook.reset(snapshot);
+        orderbook.reset(snapshot);
         this.options['orderbook'][symbol] = {
             'incrementalId': incrementalId,
         };
-        this.orderbooks[symbol] = storedOrderBook;
-        client.resolve(storedOrderBook, messageHash);
+        this.orderbooks[symbol] = orderbook;
+        client.resolve(orderbook, messageHash);
     }
     pairToSymbol(pair) {
         const parts = pair.split(':');
@@ -1437,7 +1437,8 @@ export default class cex extends cexRest {
     handleMessage(client, message) {
         const ok = this.safeString(message, 'ok');
         if (ok === 'error') {
-            return this.handleErrorMessage(client, message);
+            this.handleErrorMessage(client, message);
+            return;
         }
         const event = this.safeString(message, 'e');
         const handlers = {
@@ -1465,9 +1466,8 @@ export default class cex extends cexRest {
         };
         const handler = this.safeValue(handlers, event);
         if (handler !== undefined) {
-            return handler.call(this, client, message);
+            handler.call(this, client, message);
         }
-        return message;
     }
     handleAuthenticationMessage(client, message) {
         //

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

@@ -16,5 +16,5 @@ export default class coinbase extends coinbaseRest {
     handleOrderBookHelper(orderbook: any, updates: any): void;
     handleOrderBook(client: any, message: any): any;
     handleSubscriptionStatus(client: any, message: any): any;
-    handleMessage(client: any, message: any): any;
+    handleMessage(client: any, message: any): void;
 }

package/js/src/pro/coinbase.js

@@ -464,7 +464,8 @@ export default class coinbase extends coinbaseRest {
             const side = this.safeString(this.options['sides'], sideId);
             const price = this.safeNumber(trade, 'price_level');
             const amount = this.safeNumber(trade, 'new_quantity');
-            orderbook[side].store(price, amount);
+            const orderbookSide = orderbook[side];
+            orderbookSide.store(price, amount);
         }
     }
     handleOrderBook(client, message) {
@@ -557,6 +558,6 @@ export default class coinbase extends coinbaseRest {
             throw new ExchangeError(errorMessage);
         }
         const method = this.safeValue(methods, channel);
-        return method.call(this, client, message);
+        method.call(this, client, message);
     }
 }

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

@@ -34,5 +34,5 @@ export default class coinbasepro extends coinbaseproRest {
     handleOrderBook(client: Client, message: any): void;
     handleSubscriptionStatus(client: Client, message: any): any;
     handleErrorMessage(client: Client, message: any): boolean;
-    handleMessage(client: Client, message: any): any;
+    handleMessage(client: Client, message: any): void;
 }

package/js/src/pro/coinbasepro.js

@@ -963,7 +963,7 @@ export default class coinbasepro extends coinbaseproRest {
             }
         }
         else {
-            return method.call(this, client, message);
+            method.call(this, client, message);
         }
     }
 }

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

@@ -24,8 +24,8 @@ export default class coinex extends coinexRest {
     handleOrders(client: Client, message: any): void;
     parseWsOrder(order: any, market?: any): Order;
     parseWsOrderStatus(status: any): string;
-    handleMessage(client: Client, message: any): any;
+    handleMessage(client: Client, message: any): void;
     handleAuthenticationMessage(client: Client, message: any): any;
     handleSubscriptionStatus(client: Client, message: any): void;
-    authenticate(params?: {}): any;
+    authenticate(params?: {}): Promise<any>;
 }

package/js/src/pro/coinex.js

@@ -656,29 +656,29 @@ export default class coinex extends coinexRest {
         //
         const params = this.safeValue(message, 'params', []);
         const fullOrderBook = this.safeValue(params, 0);
-        let orderBook = this.safeValue(params, 1);
+        let orderbook = this.safeValue(params, 1);
         const marketId = this.safeString(params, 2);
         const defaultType = this.safeString(this.options, 'defaultType');
         const market = this.safeMarket(marketId, undefined, undefined, defaultType);
         const symbol = market['symbol'];
         const name = 'orderbook';
         const messageHash = name + ':' + symbol;
-        const timestamp = this.safeInteger(orderBook, 'time');
+        const timestamp = this.safeInteger(orderbook, 'time');
         const currentOrderBook = this.safeValue(this.orderbooks, symbol);
         if (fullOrderBook) {
-            const snapshot = this.parseOrderBook(orderBook, symbol, timestamp);
+            const snapshot = this.parseOrderBook(orderbook, symbol, timestamp);
             if (currentOrderBook === undefined) {
-                orderBook = this.orderBook(snapshot);
-                this.orderbooks[symbol] = orderBook;
+                orderbook = this.orderBook(snapshot);
+                this.orderbooks[symbol] = orderbook;
             }
             else {
-                orderBook = this.orderbooks[symbol];
-                orderBook.reset(snapshot);
+                orderbook = this.orderbooks[symbol];
+                orderbook.reset(snapshot);
             }
         }
         else {
-            const asks = this.safeValue(orderBook, 'asks', []);
-            const bids = this.safeValue(orderBook, 'bids', []);
+            const asks = this.safeValue(orderbook, 'asks', []);
+            const bids = this.safeValue(orderbook, 'bids', []);
             this.handleDeltas(currentOrderBook['asks'], asks);
             this.handleDeltas(currentOrderBook['bids'], bids);
             currentOrderBook['nonce'] = timestamp;
@@ -999,9 +999,10 @@ export default class coinex extends coinexRest {
         };
         const handler = this.safeValue(handlers, method);
         if (handler !== undefined) {
-            return handler.call(this, client, message);
+            handler.call(this, client, message);
+            return;
         }
-        return this.handleSubscriptionStatus(client, message);
+        this.handleSubscriptionStatus(client, message);
     }
     handleAuthenticationMessage(client, message) {
         //
@@ -1025,7 +1026,8 @@ export default class coinex extends coinexRest {
         if (subscription !== undefined) {
             const futureIndex = this.safeString(subscription, 'future');
             if (futureIndex === 'ohlcv') {
-                return this.handleOHLCV(client, message);
+                this.handleOHLCV(client, message);
+                return;
             }
             const future = this.safeValue(client.futures, futureIndex);
             if (future !== undefined) {
@@ -1034,7 +1036,7 @@ export default class coinex extends coinexRest {
             delete client.subscriptions[id];
         }
     }
-    authenticate(params = {}) {
+    async authenticate(params = {}) {
         let type = undefined;
         [type, params] = this.handleMarketTypeAndParams('authenticate', undefined, params);
         const url = this.urls['api']['ws'][type];

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

@@ -39,5 +39,5 @@ export default class currencycom extends currencycomRest {
     watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     handleDeltas(bookside: any, deltas: any): void;
     handleOrderBook(client: Client, message: any): void;
-    handleMessage(client: Client, message: any): any;
+    handleMessage(client: Client, message: any): void;
 }

package/js/src/pro/currencycom.js

@@ -535,10 +535,11 @@ export default class currencycom extends currencycomRest {
                         };
                         const method = this.safeValue(methods, subscriptionDestination);
                         if (method === undefined) {
-                            return message;
+                            return;
                         }
                         else {
-                            return method.call(this, client, message, subscription);
+                            method.call(this, client, message, subscription);
+                            return;
                         }
                     }
                 }
@@ -553,11 +554,8 @@ export default class currencycom extends currencycomRest {
                 'ping': this.handlePong,
             };
             const method = this.safeValue(methods, destination);
-            if (method === undefined) {
-                return message;
-            }
-            else {
-                return method.call(this, client, message);
+            if (method !== undefined) {
+                method.call(this, client, message);
             }
         }
     }

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

@@ -21,7 +21,7 @@ export default class deribit extends deribitRest {
     handleOrders(client: Client, message: any): void;
     watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     handleOHLCV(client: Client, message: any): void;
-    handleMessage(client: Client, message: any): any;
+    handleMessage(client: Client, message: any): void;
     handleAuthenticationMessage(client: Client, message: any): any;
-    authenticate(params?: {}): any;
+    authenticate(params?: {}): Promise<any>;
 }

package/js/src/pro/deribit.js

@@ -762,16 +762,16 @@ export default class deribit extends deribitRest {
             };
             const handler = this.safeValue(handlers, channelId);
             if (handler !== undefined) {
-                return handler.call(this, client, message);
+                handler.call(this, client, message);
+                return;
             }
             throw new NotSupported(this.id + ' no handler found for this message ' + this.json(message));
         }
         const result = this.safeValue(message, 'result', {});
         const accessToken = this.safeString(result, 'access_token');
         if (accessToken !== undefined) {
-            return this.handleAuthenticationMessage(client, message);
+            this.handleAuthenticationMessage(client, message);
         }
-        return message;
     }
     handleAuthenticationMessage(client, message) {
         //
@@ -795,7 +795,7 @@ export default class deribit extends deribitRest {
         client.resolve(message, messageHash);
         return message;
     }
-    authenticate(params = {}) {
+    async authenticate(params = {}) {
         const url = this.urls['api']['ws'];
         const client = this.client(url);
         const time = this.milliseconds();

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

@@ -18,9 +18,9 @@ export default class exmo extends exmoRest {
     handleOrderBook(client: Client, message: any): void;
     handleDelta(bookside: any, delta: any): void;
     handleDeltas(bookside: any, deltas: any): void;
-    handleMessage(client: Client, message: any): any;
+    handleMessage(client: Client, message: any): void;
     handleSubscribed(client: Client, message: any): any;
     handleInfo(client: Client, message: any): any;
     handleAuthenticationMessage(client: Client, message: any): void;
-    authenticate(params?: {}): any;
+    authenticate(params?: {}): Promise<any>;
 }

package/js/src/pro/exmo.js

@@ -515,25 +515,25 @@ export default class exmo extends exmoRest {
         const orderBook = this.safeValue(message, 'data', {});
         const messageHash = 'orderbook:' + symbol;
         const timestamp = this.safeInteger(message, 'ts');
-        let storedOrderBook = this.safeValue(this.orderbooks, symbol);
-        if (storedOrderBook === undefined) {
-            storedOrderBook = this.orderBook({});
-            this.orderbooks[symbol] = storedOrderBook;
+        let orderbook = this.safeValue(this.orderbooks, symbol);
+        if (orderbook === undefined) {
+            orderbook = this.orderBook({});
+            this.orderbooks[symbol] = orderbook;
         }
         const event = this.safeString(message, 'event');
         if (event === 'snapshot') {
             const snapshot = this.parseOrderBook(orderBook, symbol, timestamp, 'bid', 'ask');
-            storedOrderBook.reset(snapshot);
+            orderbook.reset(snapshot);
         }
         else {
             const asks = this.safeValue(orderBook, 'ask', []);
             const bids = this.safeValue(orderBook, 'bid', []);
-            this.handleDeltas(storedOrderBook['asks'], asks);
-            this.handleDeltas(storedOrderBook['bids'], bids);
-            storedOrderBook['timestamp'] = timestamp;
-            storedOrderBook['datetime'] = this.iso8601(timestamp);
+            this.handleDeltas(orderbook['asks'], asks);
+            this.handleDeltas(orderbook['bids'], bids);
+            orderbook['timestamp'] = timestamp;
+            orderbook['datetime'] = this.iso8601(timestamp);
         }
-        client.resolve(storedOrderBook, messageHash);
+        client.resolve(orderbook, messageHash);
     }
     handleDelta(bookside, delta) {
         const bidAsk = this.parseBidAsk(delta, 0, 1);
@@ -568,7 +568,8 @@ export default class exmo extends exmoRest {
         };
         const eventHandler = this.safeValue(events, event);
         if (eventHandler !== undefined) {
-            return eventHandler.call(this, client, message);
+            eventHandler.call(this, client, message);
+            return;
         }
         if ((event === 'update') || (event === 'snapshot')) {
             const topic = this.safeString(message, 'topic');
@@ -590,7 +591,8 @@ export default class exmo extends exmoRest {
                 };
                 const handler = this.safeValue(handlers, channel);
                 if (handler !== undefined) {
-                    return handler.call(this, client, message);
+                    handler.call(this, client, message);
+                    return;
                 }
             }
         }
@@ -631,7 +633,7 @@ export default class exmo extends exmoRest {
         const messageHash = 'authenticated';
         client.resolve(message, messageHash);
     }
-    authenticate(params = {}) {
+    async authenticate(params = {}) {
         const messageHash = 'authenticated';
         const [type, query] = this.handleMarketTypeAndParams('authenticate', undefined, params);
         const url = this.urls['api']['ws'][type];

package/js/src/pro/gate.js

@@ -210,7 +210,7 @@ export default class gate extends gateRest {
                 // max limit is 100
                 const subscription = client.subscriptions[messageHash];
                 const limit = this.safeInteger(subscription, 'limit');
-                this.spawn(this.loadOrderBook, client, messageHash, symbol, limit);
+                this.spawn(this.loadOrderBook, client, messageHash, symbol, limit, {}); // needed for c#, number of args needs to match
             }
             storedOrderBook.cache.push(delta);
             return;

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

@@ -20,6 +20,6 @@ export default class gemini extends geminiRest {
     parseWsOrderStatus(status: any): string;
     parseWsOrderType(type: any): string;
     handleError(client: Client, message: any): void;
-    handleMessage(client: Client, message: any): any;
+    handleMessage(client: Client, message: any): void;
     authenticate(params?: {}): Promise<void>;
 }

package/js/src/pro/gemini.js

@@ -591,7 +591,8 @@ export default class gemini extends geminiRest {
         //
         const isArray = Array.isArray(message);
         if (isArray) {
-            return this.handleOrder(client, message);
+            this.handleOrder(client, message);
+            return;
         }
         const reason = this.safeString(message, 'reason');
         if (reason === 'error') {
@@ -605,7 +606,8 @@ export default class gemini extends geminiRest {
         };
         const type = this.safeString(message, 'type', '');
         if (type.indexOf('candles') >= 0) {
-            return this.handleOHLCV(client, message);
+            this.handleOHLCV(client, message);
+            return;
         }
         const method = this.safeValue(methods, type);
         if (method !== undefined) {

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

@@ -5,7 +5,7 @@ import { Str, OrderBook, Order, Trade, Ticker, Balances } from '../base/types';
 export default class hitbtc extends hitbtcRest {
     describe(): any;
     authenticate(): Promise<any>;
-    subscribePublic(name: string, symbols?: Strings, params?: {}): Promise<any>;
+    subscribePublic(name: string, messageHashPrefix: string, symbols?: Strings, params?: {}): Promise<any>;
     subscribePrivate(name: string, symbol?: Str, params?: {}): Promise<any>;
     tradeRequest(name: string, params?: {}): Promise<any>;
     watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
@@ -29,7 +29,7 @@ export default class hitbtc extends hitbtcRest {
     parseWsOrderTrade(trade: any, market?: any): Trade;
     parseWsOrder(order: any, market?: any): Order;
     watchBalance(params?: {}): Promise<Balances>;
-    createOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: any, price?: any, params?: {}): Promise<Order>;
+    createOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, params?: {}): Promise<Order>;
     cancelOrderWs(id: string, symbol?: Str, params?: {}): Promise<Order>;
     cancelAllOrdersWs(symbol?: Str, params?: {}): Promise<any>;
     fetchOpenOrdersWs(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;

package/js/src/pro/hitbtc.js

@@ -118,7 +118,7 @@ export default class hitbtc extends hitbtcRest {
         }
         return future;
     }
-    async subscribePublic(name, symbols = undefined, params = {}) {
+    async subscribePublic(name, messageHashPrefix, symbols = undefined, params = {}) {
         /**
          * @ignore
          * @method
@@ -128,7 +128,7 @@ export default class hitbtc extends hitbtcRest {
          */
         await this.loadMarkets();
         const url = this.urls['api']['ws']['public'];
-        let messageHash = name;
+        let messageHash = messageHashPrefix;
         if (symbols !== undefined) {
             messageHash = messageHash + '::' + symbols.join(',');
         }
@@ -223,7 +223,7 @@ export default class hitbtc extends hitbtcRest {
                 'symbols': [market['id']],
             },
         };
-        const orderbook = await this.subscribePublic(name, [symbol], this.deepExtend(request, params));
+        const orderbook = await this.subscribePublic(name, name, [symbol], this.deepExtend(request, params));
         return orderbook.limit();
     }
     handleOrderBook(client, message) {
@@ -316,7 +316,7 @@ export default class hitbtc extends hitbtcRest {
                 'symbols': [market['id']],
             },
         };
-        const result = await this.subscribePublic(name, [symbol], this.deepExtend(request, params));
+        const result = await this.subscribePublic(name, 'ticker', [symbol], this.deepExtend(request, params));
         return this.safeValue(result, symbol);
     }
     async watchTickers(symbols = undefined, params = {}) {
@@ -352,7 +352,7 @@ export default class hitbtc extends hitbtcRest {
                 'symbols': marketIds,
             },
         };
-        const tickers = await this.subscribePublic(name, symbols, this.deepExtend(request, params));
+        const tickers = await this.subscribePublic(name, 'tickers', symbols, this.deepExtend(request, params));
         if (this.newUpdates) {
             return tickers;
         }
@@ -411,7 +411,7 @@ export default class hitbtc extends hitbtcRest {
             const messageHash = channel + '::' + symbol;
             client.resolve(newTickers, messageHash);
         }
-        const messageHashes = this.findMessageHashes(client, channel + '::');
+        const messageHashes = this.findMessageHashes(client, 'tickers::');
         for (let i = 0; i < messageHashes.length; i++) {
             const messageHash = messageHashes[i];
             const parts = messageHash.split('::');
@@ -504,7 +504,8 @@ export default class hitbtc extends hitbtcRest {
         if (limit !== undefined) {
             request['limit'] = limit;
         }
-        const trades = await this.subscribePublic('trades', [symbol], this.deepExtend(request, params));
+        const name = 'trades';
+        const trades = await this.subscribePublic(name, name, [symbol], this.deepExtend(request, params));
         if (this.newUpdates) {
             limit = trades.getLimit(symbol, limit);
         }
@@ -633,7 +634,7 @@ export default class hitbtc extends hitbtcRest {
         if (limit !== undefined) {
             request['params']['limit'] = limit;
         }
-        const ohlcv = await this.subscribePublic(name, [symbol], this.deepExtend(request, params));
+        const ohlcv = await this.subscribePublic(name, name, [symbol], this.deepExtend(request, params));
         if (this.newUpdates) {
             limit = ohlcv.getLimit(symbol, limit);
         }

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

@@ -8,9 +8,9 @@ export default class hollaex extends hollaexRest {
     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<Trade[]>;
-    handleMyTrades(client: Client, message: any, subscription?: any): number;
+    handleMyTrades(client: Client, message: any, subscription?: any): void;
     watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
-    handleOrder(client: Client, message: any, subscription?: any): number;
+    handleOrder(client: Client, message: any, subscription?: any): void;
     watchBalance(params?: {}): Promise<Balances>;
     handleBalance(client: Client, message: any): void;
     watchPublic(messageHash: any, params?: {}): Promise<any>;

package/js/src/pro/hollaex.js

@@ -221,7 +221,7 @@ export default class hollaex extends hollaexRest {
         // when the user does not have any trades yet
         const dataLength = rawTrades.length;
         if (dataLength === 0) {
-            return 0;
+            return;
         }
         if (this.myTrades === undefined) {
             const limit = this.safeInteger(this.options, 'tradesLimit', 1000);
@@ -335,7 +335,7 @@ export default class hollaex extends hollaexRest {
         // usually the first message is an empty array
         const dataLength = data.length;
         if (dataLength === 0) {
-            return 0;
+            return;
         }
         if (this.orders === undefined) {
             const limit = this.safeInteger(this.options, 'ordersLimit', 1000);

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

@@ -28,9 +28,9 @@ export default class htx extends htxRest {
     handlePositions(client: any, message: any): void;
     watchBalance(params?: {}): Promise<Balances>;
     handleBalance(client: Client, message: any): void;
-    handleSubscriptionStatus(client: Client, message: any): any;
+    handleSubscriptionStatus(client: Client, message: any): void;
     handleSystemStatus(client: Client, message: any): any;
-    handleSubject(client: Client, message: any): any;
+    handleSubject(client: Client, message: any): void;
     pong(client: any, message: any): Promise<void>;
     handlePing(client: Client, message: any): void;
     handleAuthenticate(client: Client, message: any): void;

package/js/src/pro/htx.js

@@ -472,6 +472,7 @@ export default class htx extends htxRest {
             delete client.subscriptions[messageHash];
             client.reject(e, messageHash);
         }
+        return undefined;
     }
     handleDelta(bookside, delta) {
         const price = this.safeFloat(delta, 0);
@@ -1692,14 +1693,14 @@ export default class htx extends htxRest {
         if (subscription !== undefined) {
             const method = this.safeValue(subscription, 'method');
             if (method !== undefined) {
-                return method.call(this, client, message, subscription);
+                method.call(this, client, message, subscription);
+                return;
             }
             // clean up
             if (id in client.subscriptions) {
                 delete client.subscriptions[id];
             }
         }
-        return message;
     }
     handleSystemStatus(client, message) {
         //
@@ -1808,11 +1809,9 @@ export default class htx extends htxRest {
                 'kline': this.handleOHLCV,
             };
             const method = this.safeValue(methods, methodName);
-            if (method === undefined) {
-                return message;
-            }
-            else {
-                return method.call(this, client, message);
+            if (method !== undefined) {
+                method.call(this, client, message);
+                return;
             }
         }
         // private spot subjects

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

@@ -20,7 +20,7 @@ export default class huobijp extends huobijpRest {
     handleOrderBookSubscription(client: Client, message: any, subscription: any): void;
     handleSubscriptionStatus(client: Client, message: any): any;
     handleSystemStatus(client: Client, message: any): any;
-    handleSubject(client: Client, message: any): any;
+    handleSubject(client: Client, message: any): void;
     pong(client: any, message: any): Promise<void>;
     handlePing(client: Client, message: any): void;
     handleErrorMessage(client: Client, message: any): any;

package/js/src/pro/huobijp.js

@@ -364,6 +364,7 @@ export default class huobijp extends huobijpRest {
             delete client.subscriptions[messageHash];
             client.reject(e, messageHash);
         }
+        return undefined;
     }
     handleDelta(bookside, delta) {
         const price = this.safeFloat(delta, 0);
@@ -529,11 +530,8 @@ export default class huobijp extends huobijpRest {
                 // ...
             };
             const method = this.safeValue(methods, methodName);
-            if (method === undefined) {
-                return message;
-            }
-            else {
-                return method.call(this, client, message);
+            if (method !== undefined) {
+                method.call(this, client, message);
             }
         }
     }

package/js/src/pro/idex.js

@@ -327,7 +327,7 @@ export default class idex extends idexRest {
                         const symbol = this.safeSymbol(marketId);
                         if (!(symbol in this.orderbooks)) {
                             const orderbook = this.countedOrderBook({});
-                            orderbook.cache = [];
+                            // orderbook.cache = []; // cache is never used?
                             this.orderbooks[symbol] = orderbook;
                         }
                         this.spawn(this.fetchOrderBookSnapshot, client, symbol);

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

@@ -13,5 +13,5 @@ export default class independentreserve extends independentreserveRest {
     handleDeltas(bookside: any, deltas: any): void;
     handleHeartbeat(client: Client, message: any): any;
     handleSubscriptions(client: Client, message: any): any;
-    handleMessage(client: Client, message: any): any;
+    handleMessage(client: Client, message: any): void;
 }