ccxt 4.2.30 → 4.2.34

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);
             }
         }
     }

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

@@ -47,19 +47,20 @@ class kucoin extends kucoin$1 {
             },
         });
     }
-    negotiate(privateChannel, params = {}) {
+    async negotiate(privateChannel, params = {}) {
         const connectId = privateChannel ? 'private' : 'public';
         const urls = this.safeValue(this.options, 'urls', {});
         const spawaned = this.safeValue(urls, connectId);
         if (spawaned !== undefined) {
-            return spawaned;
+            return await spawaned;
         }
         // we store an awaitable to the url
         // so that multiple calls don't asynchronously
         // fetch different urls and overwrite each other
         urls[connectId] = this.spawn(this.negotiateHelper, privateChannel, params);
         this.options['urls'] = urls;
-        return urls[connectId];
+        const future = urls[connectId];
+        return await future;
     }
     async negotiateHelper(privateChannel, params = {}) {
         let response = undefined;
@@ -545,7 +546,7 @@ class kucoin extends kucoin$1 {
             const limit = this.safeInteger(subscription, 'limit');
             const snapshotDelay = this.handleOption('watchOrderBook', 'snapshotDelay', 5);
             if (cacheLength === snapshotDelay) {
-                this.spawn(this.loadOrderBook, client, messageHash, symbol, limit);
+                this.spawn(this.loadOrderBook, client, messageHash, symbol, limit, {});
             }
             storedOrderBook.cache.push(data);
             return;
@@ -987,7 +988,8 @@ class kucoin extends kucoin$1 {
         //
         const topic = this.safeString(message, 'topic');
         if (topic === '/market/ticker:all') {
-            return this.handleTicker(client, message);
+            this.handleTicker(client, message);
+            return;
         }
         const subject = this.safeString(message, 'subject');
         const methods = {
@@ -1002,11 +1004,8 @@ class kucoin extends kucoin$1 {
             'stopOrder': this.handleOrder,
         };
         const method = this.safeValue(methods, subject);
-        if (method === undefined) {
-            return message;
-        }
-        else {
-            return method.call(this, client, message);
+        if (method !== undefined) {
+            method.call(this, client, message);
         }
     }
     ping(client) {
@@ -1054,7 +1053,7 @@ class kucoin extends kucoin$1 {
         };
         const method = this.safeValue(methods, type);
         if (method !== undefined) {
-            return method.call(this, client, message);
+            method.call(this, client, message);
         }
     }
 }

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

@@ -57,19 +57,20 @@ class kucoinfutures extends kucoinfutures$1 {
             },
         });
     }
-    negotiate(privateChannel, params = {}) {
+    async negotiate(privateChannel, params = {}) {
         const connectId = privateChannel ? 'private' : 'public';
         const urls = this.safeValue(this.options, 'urls', {});
         const spawaned = this.safeValue(urls, connectId);
         if (spawaned !== undefined) {
-            return spawaned;
+            return await spawaned;
         }
         // we store an awaitable to the url
         // so that multiple calls don't asynchronously
         // fetch different urls and overwrite each other
-        urls[connectId] = this.spawn(this.negotiateHelper, privateChannel, params);
+        urls[connectId] = this.spawn(this.negotiateHelper, privateChannel, params); // we have to wait here otherwsie in c# will not work
         this.options['urls'] = urls;
-        return urls[connectId];
+        const future = urls[connectId];
+        return await future;
     }
     async negotiateHelper(privateChannel, params = {}) {
         let response = undefined;
@@ -582,6 +583,9 @@ class kucoinfutures extends kucoinfutures$1 {
         const messageHash = 'orderbook:' + symbol;
         const storedOrderBook = this.safeValue(this.orderbooks, symbol);
         const nonce = this.safeInteger(storedOrderBook, 'nonce');
+        if (storedOrderBook === undefined) {
+            return; // this shouldn't be needed, but for some reason sometimes this runs before handleOrderBookSubscription in c#
+        }
         const deltaEnd = this.safeInteger(data, 'sequence');
         if (nonce === undefined) {
             const cacheLength = storedOrderBook.cache.length;
@@ -600,7 +604,7 @@ class kucoinfutures extends kucoinfutures$1 {
             const limit = this.safeInteger(subscription, 'limit');
             const snapshotDelay = this.handleOption('watchOrderBook', 'snapshotDelay', 5);
             if (cacheLength === snapshotDelay) {
-                this.spawn(this.loadOrderBook, client, messageHash, symbol, limit);
+                this.spawn(this.loadOrderBook, client, messageHash, symbol, limit, {});
             }
             storedOrderBook.cache.push(data);
             return;
@@ -928,11 +932,8 @@ class kucoinfutures extends kucoinfutures$1 {
             'position.adjustRiskLimit': this.handlePosition,
         };
         const method = this.safeValue(methods, subject);
-        if (method === undefined) {
-            return message;
-        }
-        else {
-            return method.call(this, client, message);
+        if (method !== undefined) {
+            method.call(this, client, message);
         }
     }
     ping(client) {
@@ -981,7 +982,7 @@ class kucoinfutures extends kucoinfutures$1 {
         };
         const method = this.safeValue(methods, type);
         if (method !== undefined) {
-            return method.call(this, client, message);
+            method.call(this, client, message);
         }
     }
 }

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

@@ -776,17 +776,17 @@ class lbank extends lbank$1 {
         const orderBook = this.safeValue(message, 'depth', message);
         const datetime = this.safeString(message, 'TS');
         const timestamp = this.parse8601(datetime);
-        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 snapshot = this.parseOrderBook(orderBook, symbol, timestamp, 'bids', 'asks');
-        storedOrderBook.reset(snapshot);
+        orderbook.reset(snapshot);
         let messageHash = 'orderbook:' + symbol;
-        client.resolve(storedOrderBook, messageHash);
+        client.resolve(orderbook, messageHash);
         messageHash = 'fetchOrderbook:' + symbol;
-        client.resolve(storedOrderBook, messageHash);
+        client.resolve(orderbook, messageHash);
     }
     handleErrorMessage(client, message) {
         //
@@ -814,7 +814,8 @@ class lbank extends lbank$1 {
     handleMessage(client, message) {
         const status = this.safeString(message, 'status');
         if (status === 'error') {
-            return this.handleErrorMessage(client, message);
+            this.handleErrorMessage(client, message);
+            return;
         }
         const type = this.safeString2(message, 'type', 'action');
         if (type === 'ping') {
@@ -830,9 +831,8 @@ class lbank extends lbank$1 {
         };
         const handler = this.safeValue(handlers, type);
         if (handler !== undefined) {
-            return handler.call(this, client, message);
+            handler.call(this, client, message);
         }
-        return message;
     }
     async authenticate(params = {}) {
         // when we implement more private streams, we need to refactor the authentication