ccxt 4.2.31 → 4.2.35

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

@@ -960,15 +960,15 @@ class cex extends cex$1 {
         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(':');
@@ -1434,7 +1434,8 @@ class cex extends cex$1 {
     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 = {
@@ -1462,9 +1463,8 @@ class cex extends cex$1 {
         };
         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/dist/cjs/src/pro/coinbase.js

@@ -461,7 +461,8 @@ class coinbase extends coinbase$1 {
             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) {
@@ -554,7 +555,7 @@ class coinbase extends coinbase$1 {
             throw new errors.ExchangeError(errorMessage);
         }
         const method = this.safeValue(methods, channel);
-        return method.call(this, client, message);
+        method.call(this, client, message);
     }
 }
 

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

@@ -960,7 +960,7 @@ class coinbasepro extends coinbasepro$1 {
             }
         }
         else {
-            return method.call(this, client, message);
+            method.call(this, client, message);
         }
     }
 }

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

@@ -653,29 +653,29 @@ class coinex extends coinex$1 {
         //
         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;
@@ -996,9 +996,10 @@ class coinex extends coinex$1 {
         };
         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) {
         //
@@ -1022,7 +1023,8 @@ class coinex extends coinex$1 {
         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) {
@@ -1031,7 +1033,7 @@ class coinex extends coinex$1 {
             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/dist/cjs/src/pro/currencycom.js

@@ -532,10 +532,11 @@ class currencycom extends currencycom$1 {
                         };
                         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;
                         }
                     }
                 }
@@ -550,11 +551,8 @@ class currencycom extends currencycom$1 {
                 '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/dist/cjs/src/pro/deribit.js

@@ -757,16 +757,16 @@ class deribit extends deribit$1 {
             };
             const handler = this.safeValue(handlers, channelId);
             if (handler !== undefined) {
-                return handler.call(this, client, message);
+                handler.call(this, client, message);
+                return;
             }
             throw new errors.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) {
         //
@@ -790,7 +790,7 @@ class deribit extends deribit$1 {
         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/dist/cjs/src/pro/exmo.js

@@ -512,25 +512,25 @@ class exmo extends exmo$1 {
         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);
@@ -565,7 +565,8 @@ class exmo extends exmo$1 {
         };
         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');
@@ -587,7 +588,8 @@ class exmo extends exmo$1 {
                 };
                 const handler = this.safeValue(handlers, channel);
                 if (handler !== undefined) {
-                    return handler.call(this, client, message);
+                    handler.call(this, client, message);
+                    return;
                 }
             }
         }
@@ -628,7 +630,7 @@ class exmo extends exmo$1 {
         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/dist/cjs/src/pro/gate.js

@@ -207,7 +207,7 @@ class gate extends gate$1 {
                 // 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/dist/cjs/src/pro/gemini.js

@@ -588,7 +588,8 @@ class gemini extends gemini$1 {
         //
         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') {
@@ -602,7 +603,8 @@ class gemini extends gemini$1 {
         };
         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/dist/cjs/src/pro/hitbtc.js

@@ -115,7 +115,7 @@ class hitbtc extends hitbtc$1 {
         }
         return future;
     }
-    async subscribePublic(name, symbols = undefined, params = {}) {
+    async subscribePublic(name, messageHashPrefix, symbols = undefined, params = {}) {
         /**
          * @ignore
          * @method
@@ -125,7 +125,7 @@ class hitbtc extends hitbtc$1 {
          */
         await this.loadMarkets();
         const url = this.urls['api']['ws']['public'];
-        let messageHash = name;
+        let messageHash = messageHashPrefix;
         if (symbols !== undefined) {
             messageHash = messageHash + '::' + symbols.join(',');
         }
@@ -220,7 +220,7 @@ class hitbtc extends hitbtc$1 {
                 '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) {
@@ -313,7 +313,7 @@ class hitbtc extends hitbtc$1 {
                 '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 = {}) {
@@ -349,7 +349,7 @@ class hitbtc extends hitbtc$1 {
                 '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;
         }
@@ -408,7 +408,7 @@ class hitbtc extends hitbtc$1 {
             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('::');
@@ -501,7 +501,8 @@ class hitbtc extends hitbtc$1 {
         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);
         }
@@ -630,7 +631,7 @@ class hitbtc extends hitbtc$1 {
         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/dist/cjs/src/pro/hollaex.js

@@ -218,7 +218,7 @@ class hollaex extends hollaex$1 {
         // 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);
@@ -332,7 +332,7 @@ class hollaex extends hollaex$1 {
         // 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/dist/cjs/src/pro/htx.js

@@ -469,6 +469,7 @@ class htx extends htx$1 {
             delete client.subscriptions[messageHash];
             client.reject(e, messageHash);
         }
+        return undefined;
     }
     handleDelta(bookside, delta) {
         const price = this.safeFloat(delta, 0);
@@ -1689,14 +1690,14 @@ class htx extends htx$1 {
         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) {
         //
@@ -1805,11 +1806,9 @@ class htx extends htx$1 {
                 '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/dist/cjs/src/pro/huobijp.js

@@ -361,6 +361,7 @@ class huobijp extends huobijp$1 {
             delete client.subscriptions[messageHash];
             client.reject(e, messageHash);
         }
+        return undefined;
     }
     handleDelta(bookside, delta) {
         const price = this.safeFloat(delta, 0);
@@ -526,11 +527,8 @@ class huobijp extends huobijp$1 {
                 // ...
             };
             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/dist/cjs/src/pro/idex.js

@@ -324,7 +324,7 @@ class idex extends idex$1 {
                         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/dist/cjs/src/pro/independentreserve.js

@@ -178,28 +178,28 @@ class independentreserve extends independentreserve$1 {
         const subscription = this.safeValue(client.subscriptions, messageHash, {});
         const receivedSnapshot = this.safeBool(subscription, 'receivedSnapshot', false);
         const timestamp = this.safeInteger(message, 'Time');
-        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;
         }
         if (event === 'OrderBookSnapshot') {
             const snapshot = this.parseOrderBook(orderBook, symbol, timestamp, 'Bids', 'Offers', 'Price', 'Volume');
-            storedOrderBook.reset(snapshot);
+            orderbook.reset(snapshot);
             subscription['receivedSnapshot'] = true;
         }
         else {
             const asks = this.safeValue(orderBook, 'Offers', []);
             const bids = this.safeValue(orderBook, 'Bids', []);
-            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);
         }
         const checksum = this.safeValue(this.options, 'checksum', true);
         if (checksum && receivedSnapshot) {
-            const storedAsks = storedOrderBook['asks'];
-            const storedBids = storedOrderBook['bids'];
+            const storedAsks = orderbook['asks'];
+            const storedBids = orderbook['bids'];
             const asksLength = storedAsks.length;
             const bidsLength = storedBids.length;
             let payload = '';
@@ -221,7 +221,7 @@ class independentreserve extends independentreserve$1 {
             }
         }
         if (receivedSnapshot) {
-            client.resolve(storedOrderBook, messageHash);
+            client.resolve(orderbook, messageHash);
         }
     }
     valueToChecksum(value) {
@@ -271,7 +271,8 @@ class independentreserve extends independentreserve$1 {
         };
         const handler = this.safeValue(handlers, event);
         if (handler !== undefined) {
-            return handler.call(this, client, message);
+            handler.call(this, client, message);
+            return;
         }
         throw new errors.NotSupported(this.id + ' received an unsupported message: ' + this.json(message));
     }

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

@@ -656,7 +656,7 @@ class kraken extends kraken$1 {
                 const side = sides[key];
                 const bookside = orderbook[side];
                 const deltas = this.safeValue(message[1], key, []);
-                timestamp = this.handleDeltas(bookside, deltas, timestamp);
+                timestamp = this.customHandleDeltas(bookside, deltas, timestamp);
             }
             orderbook['symbol'] = symbol;
             orderbook['timestamp'] = timestamp;
@@ -688,11 +688,11 @@ class kraken extends kraken$1 {
             const storedBids = orderbook['bids'];
             let example = undefined;
             if (a !== undefined) {
-                timestamp = this.handleDeltas(storedAsks, a, timestamp);
+                timestamp = this.customHandleDeltas(storedAsks, a, timestamp);
                 example = this.safeValue(a, 0);
             }
             if (b !== undefined) {
-                timestamp = this.handleDeltas(storedBids, b, timestamp);
+                timestamp = this.customHandleDeltas(storedBids, b, timestamp);
                 example = this.safeValue(b, 0);
             }
             // don't remove this line or I will poop on your face
@@ -747,7 +747,7 @@ class kraken extends kraken$1 {
             return joined;
         }
     }
-    handleDeltas(bookside, deltas, timestamp = undefined) {
+    customHandleDeltas(bookside, deltas, timestamp = undefined) {
         for (let j = 0; j < deltas.length; j++) {
             const delta = deltas[j];
             const price = this.parseNumber(delta[0]);
@@ -1292,7 +1292,7 @@ class kraken extends kraken$1 {
         //         "subscription": { name: "ticker" }
         //     }
         //
-        const errorMessage = this.safeValue(message, 'errorMessage');
+        const errorMessage = this.safeString(message, 'errorMessage');
         if (errorMessage !== undefined) {
             const requestId = this.safeValue(message, 'reqid');
             if (requestId !== undefined) {
@@ -1300,7 +1300,7 @@ class kraken extends kraken$1 {
                 const broadKey = this.findBroadlyMatchedKey(broad, errorMessage);
                 let exception = undefined;
                 if (broadKey === undefined) {
-                    exception = new errors.ExchangeError(errorMessage);
+                    exception = new errors.ExchangeError(errorMessage); // c# requirement to convert the errorMessage to string
                 }
                 else {
                     exception = new broad[broadKey](errorMessage);
@@ -1330,11 +1330,8 @@ class kraken extends kraken$1 {
                 'ownTrades': this.handleMyTrades,
             };
             const method = this.safeValue2(methods, name, channelName);
-            if (method === undefined) {
-                return message;
-            }
-            else {
-                return method.call(this, client, message, subscription);
+            if (method !== undefined) {
+                method.call(this, client, message, subscription);
             }
         }
         else {
@@ -1350,11 +1347,8 @@ class kraken extends kraken$1 {
                     'cancelAllStatus': this.handleCancelAllOrders,
                 };
                 const method = this.safeValue(methods, event);
-                if (method === undefined) {
-                    return message;
-                }
-                else {
-                    return method.call(this, client, message);
+                if (method !== undefined) {
+                    method.call(this, client, message);
                 }
             }
         }

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

@@ -1064,13 +1064,15 @@ class krakenfutures extends krakenfutures$1 {
             const bid = bids[i];
             const price = this.safeNumber(bid, 'price');
             const qty = this.safeNumber(bid, 'qty');
-            orderbook['bids'].store(price, qty);
+            const bidsSide = orderbook['bids'];
+            bidsSide.store(price, qty);
         }
         for (let i = 0; i < asks.length; i++) {
             const ask = asks[i];
             const price = this.safeNumber(ask, 'price');
             const qty = this.safeNumber(ask, 'qty');
-            orderbook['asks'].store(price, qty);
+            const asksSide = orderbook['asks'];
+            asksSide.store(price, qty);
         }
         orderbook['timestamp'] = timestamp;
         orderbook['datetime'] = this.iso8601(timestamp);
@@ -1099,10 +1101,12 @@ class krakenfutures extends krakenfutures$1 {
         const qty = this.safeNumber(message, 'qty');
         const timestamp = this.safeInteger(message, 'timestamp');
         if (side === 'sell') {
-            orderbook['asks'].store(price, qty);
+            const asks = orderbook['asks'];
+            asks.store(price, qty);
         }
         else {
-            orderbook['bids'].store(price, qty);
+            const bids = orderbook['bids'];
+            bids.store(price, qty);
         }
         orderbook['timestamp'] = timestamp;
         orderbook['datetime'] = this.iso8601(timestamp);
@@ -1438,7 +1442,7 @@ class krakenfutures extends krakenfutures$1 {
             this.handleAuthenticate(client, message);
         }
         else if (event === 'alert') {
-            return this.handleErrorMessage(client, message);
+            this.handleErrorMessage(client, message);
         }
         else if (event === 'pong') {
             client.lastPong = this.milliseconds();
@@ -1465,7 +1469,7 @@ class krakenfutures extends krakenfutures$1 {
             };
             const method = this.safeValue(methods, feed);
             if (method !== undefined) {
-                return method.call(this, client, message);
+                method.call(this, client, message);
             }
         }
     }