ccxt 4.2.31 → 4.2.34

package/js/src/pro/independentreserve.js

@@ -181,28 +181,28 @@ export default class independentreserve extends independentreserveRest {
         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 = '';
@@ -224,7 +224,7 @@ export default class independentreserve extends independentreserveRest {
             }
         }
         if (receivedSnapshot) {
-            client.resolve(storedOrderBook, messageHash);
+            client.resolve(orderbook, messageHash);
         }
     }
     valueToChecksum(value) {
@@ -274,7 +274,8 @@ export default class independentreserve extends independentreserveRest {
         };
         const handler = this.safeValue(handlers, event);
         if (handler !== undefined) {
-            return handler.call(this, client, message);
+            handler.call(this, client, message);
+            return;
         }
         throw new NotSupported(this.id + ' received an unsupported message: ' + this.json(message));
     }

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

@@ -25,7 +25,7 @@ export default class kraken extends krakenRest {
     handleHeartbeat(client: Client, message: any): void;
     handleOrderBook(client: Client, message: any, subscription: any): void;
     formatNumber(n: any, length: any): string;
-    handleDeltas(bookside: any, deltas: any, timestamp?: any): any;
+    customHandleDeltas(bookside: any, deltas: any, timestamp?: any): any;
     handleSystemStatus(client: Client, message: any): any;
     authenticate(params?: {}): Promise<string>;
     watchPrivate(name: any, symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<any>;
@@ -51,5 +51,5 @@ export default class kraken extends krakenRest {
     parseWsOrder(order: any, market?: any): Order;
     handleSubscriptionStatus(client: Client, message: any): void;
     handleErrorMessage(client: Client, message: any): boolean;
-    handleMessage(client: Client, message: any): any;
+    handleMessage(client: Client, message: any): void;
 }

package/js/src/pro/kraken.js

@@ -659,7 +659,7 @@ export default class kraken extends krakenRest {
                 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;
@@ -691,11 +691,11 @@ export default class kraken extends krakenRest {
             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
@@ -750,7 +750,7 @@ export default class kraken extends krakenRest {
             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]);
@@ -1295,7 +1295,7 @@ export default class kraken extends krakenRest {
         //         "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) {
@@ -1303,7 +1303,7 @@ export default class kraken extends krakenRest {
                 const broadKey = this.findBroadlyMatchedKey(broad, errorMessage);
                 let exception = undefined;
                 if (broadKey === undefined) {
-                    exception = new ExchangeError(errorMessage);
+                    exception = new ExchangeError(errorMessage); // c# requirement to convert the errorMessage to string
                 }
                 else {
                     exception = new broad[broadKey](errorMessage);
@@ -1333,11 +1333,8 @@ export default class kraken extends krakenRest {
                 '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 {
@@ -1353,11 +1350,8 @@ export default class kraken extends krakenRest {
                     '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/js/src/pro/krakenfutures.d.ts

@@ -30,6 +30,6 @@ export default class krakenfutures extends krakenfuturesRest {
     handleMyTrades(client: Client, message: any): void;
     parseWsMyTrade(trade: any, market?: any): Trade;
     handleErrorMessage(client: Client, message: any): void;
-    handleMessage(client: any, message: any): any;
+    handleMessage(client: any, message: any): void;
     handleAuthenticate(client: Client, message: any): any;
 }

package/js/src/pro/krakenfutures.js

@@ -1067,13 +1067,15 @@ export default class krakenfutures extends krakenfuturesRest {
             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);
@@ -1102,10 +1104,12 @@ export default class krakenfutures extends krakenfuturesRest {
         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);
@@ -1441,7 +1445,7 @@ export default class krakenfutures extends krakenfuturesRest {
             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();
@@ -1468,7 +1472,7 @@ export default class krakenfutures extends krakenfuturesRest {
             };
             const method = this.safeValue(methods, feed);
             if (method !== undefined) {
-                return method.call(this, client, message);
+                method.call(this, client, message);
             }
         }
     }

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

@@ -3,7 +3,7 @@ import type { Int, Str, Strings, OrderBook, Order, Trade, Ticker, Tickers, OHLCV
 import Client from '../base/ws/Client.js';
 export default class kucoin extends kucoinRest {
     describe(): any;
-    negotiate(privateChannel: any, params?: {}): any;
+    negotiate(privateChannel: any, params?: {}): Promise<any>;
     negotiateHelper(privateChannel: any, params?: {}): Promise<string>;
     requestId(): any;
     subscribe(url: any, messageHash: any, subscriptionHash: any, params?: {}, subscription?: any): Promise<any>;
@@ -34,12 +34,12 @@ export default class kucoin extends kucoinRest {
     parseWsTrade(trade: any, market?: any): Trade;
     watchBalance(params?: {}): Promise<Balances>;
     handleBalance(client: Client, message: any): void;
-    handleSubject(client: Client, message: any): any;
+    handleSubject(client: Client, message: any): void;
     ping(client: any): {
         id: any;
         type: string;
     };
     handlePong(client: Client, message: any): void;
     handleErrorMessage(client: Client, message: any): void;
-    handleMessage(client: Client, message: any): any;
+    handleMessage(client: Client, message: any): void;
 }

package/js/src/pro/kucoin.js

@@ -50,19 +50,20 @@ export default class kucoin extends kucoinRest {
             },
         });
     }
-    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;
@@ -548,7 +549,7 @@ export default class kucoin extends kucoinRest {
             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;
@@ -990,7 +991,8 @@ export default class kucoin extends kucoinRest {
         //
         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 = {
@@ -1005,11 +1007,8 @@ export default class kucoin extends kucoinRest {
             '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) {
@@ -1057,7 +1056,7 @@ export default class kucoin extends kucoinRest {
         };
         const method = this.safeValue(methods, type);
         if (method !== undefined) {
-            return method.call(this, client, message);
+            method.call(this, client, message);
         }
     }
 }

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

@@ -3,7 +3,7 @@ import type { Int, Str, OrderBook, Order, Trade, Ticker, Balances, Position } fr
 import Client from '../base/ws/Client.js';
 export default class kucoinfutures extends kucoinfuturesRest {
     describe(): any;
-    negotiate(privateChannel: any, params?: {}): any;
+    negotiate(privateChannel: any, params?: {}): Promise<any>;
     negotiateHelper(privateChannel: any, params?: {}): Promise<string>;
     requestId(): any;
     subscribe(url: any, messageHash: any, subscriptionHash: any, subscription: any, params?: {}): Promise<any>;
@@ -35,12 +35,12 @@ export default class kucoinfutures extends kucoinfuturesRest {
     handleBalance(client: Client, message: any): void;
     handleBalanceSubscription(client: Client, message: any, subscription: any): void;
     fetchBalanceSnapshot(client: any, message: any): Promise<void>;
-    handleSubject(client: Client, message: any): any;
+    handleSubject(client: Client, message: any): void;
     ping(client: any): {
         id: any;
         type: string;
     };
     handlePong(client: Client, message: any): any;
     handleErrorMessage(client: Client, message: any): void;
-    handleMessage(client: Client, message: any): any;
+    handleMessage(client: Client, message: any): void;
 }

package/js/src/pro/kucoinfutures.js

@@ -60,19 +60,20 @@ export default class kucoinfutures extends kucoinfuturesRest {
             },
         });
     }
-    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;
@@ -585,6 +586,9 @@ export default class kucoinfutures extends kucoinfuturesRest {
         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;
@@ -603,7 +607,7 @@ export default class kucoinfutures extends kucoinfuturesRest {
             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;
@@ -931,11 +935,8 @@ export default class kucoinfutures extends kucoinfuturesRest {
             '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) {
@@ -984,7 +985,7 @@ export default class kucoinfutures extends kucoinfuturesRest {
         };
         const method = this.safeValue(methods, type);
         if (method !== undefined) {
-            return method.call(this, client, message);
+            method.call(this, client, message);
         }
     }
 }

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

@@ -24,6 +24,6 @@ export default class lbank extends lbankRest {
     handleOrderBook(client: any, message: any): void;
     handleErrorMessage(client: any, message: any): void;
     handlePing(client: Client, message: any): Promise<void>;
-    handleMessage(client: any, message: any): any;
+    handleMessage(client: any, message: any): void;
     authenticate(params?: {}): Promise<any>;
 }

package/js/src/pro/lbank.js

@@ -779,17 +779,17 @@ export default class lbank extends lbankRest {
         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) {
         //
@@ -817,7 +817,8 @@ export default class lbank extends lbankRest {
     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') {
@@ -833,9 +834,8 @@ export default class lbank extends lbankRest {
         };
         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

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

@@ -18,6 +18,6 @@ export default class luno extends lunoRest {
     };
     parseBidsAsks(bidasks: any, priceKey?: IndexType, amountKey?: IndexType, thirdKey?: IndexType): any[];
     customParseBidAsk(bidask: any, priceKey?: IndexType, amountKey?: IndexType, thirdKey?: IndexType): number[];
-    handleDelta(orderbook: any, message: any): any;
-    handleMessage(client: Client, message: any): any;
+    handleDelta(orderbook: any, message: any): void;
+    handleMessage(client: Client, message: any): void;
 }

package/js/src/pro/luno.js

@@ -194,24 +194,24 @@ export default class luno extends lunoRest {
         const symbol = subscription['symbol'];
         const messageHash = 'orderbook:' + symbol;
         const timestamp = this.safeString(message, 'timestamp');
-        let storedOrderBook = this.safeValue(this.orderbooks, symbol);
-        if (storedOrderBook === undefined) {
-            storedOrderBook = this.indexedOrderBook({});
-            this.orderbooks[symbol] = storedOrderBook;
+        let orderbook = this.safeValue(this.orderbooks, symbol);
+        if (orderbook === undefined) {
+            orderbook = this.indexedOrderBook({});
+            this.orderbooks[symbol] = orderbook;
         }
         const asks = this.safeValue(message, 'asks');
         if (asks !== undefined) {
             const snapshot = this.customParseOrderBook(message, symbol, timestamp, 'bids', 'asks', 'price', 'volume', 'id');
-            storedOrderBook.reset(snapshot);
+            orderbook.reset(snapshot);
         }
         else {
-            this.handleDelta(storedOrderBook, message);
-            storedOrderBook['timestamp'] = timestamp;
-            storedOrderBook['datetime'] = this.iso8601(timestamp);
+            this.handleDelta(orderbook, message);
+            orderbook['timestamp'] = timestamp;
+            orderbook['datetime'] = this.iso8601(timestamp);
         }
         const nonce = this.safeInteger(message, 'sequence');
-        storedOrderBook['nonce'] = nonce;
-        client.resolve(storedOrderBook, messageHash);
+        orderbook['nonce'] = nonce;
+        client.resolve(orderbook, messageHash);
     }
     customParseOrderBook(orderbook, symbol, timestamp = undefined, bidsKey = 'bids', asksKey = 'asks', priceKey = 'price', amountKey = 'volume', countOrIdKey = 2) {
         const bids = this.parseBidsAsks(this.safeValue(orderbook, bidsKey, []), priceKey, amountKey, countOrIdKey);
@@ -303,10 +303,9 @@ export default class luno extends lunoRest {
         const deleteUpdate = this.safeValue(message, 'delete_update');
         if (deleteUpdate !== undefined) {
             const orderId = this.safeString(deleteUpdate, 'order_id');
-            asksOrderSide.storeArray(0, 0, orderId);
-            bidsOrderSide.storeArray(0, 0, orderId);
+            asksOrderSide.storeArray([0, 0, orderId]);
+            bidsOrderSide.storeArray([0, 0, orderId]);
         }
-        return message;
     }
     handleMessage(client, message) {
         if (message === '') {
@@ -318,6 +317,5 @@ export default class luno extends lunoRest {
             const handler = handlers[j];
             handler.call(this, client, message, subscriptions[0]);
         }
-        return message;
     }
 }

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

@@ -35,8 +35,8 @@ export default class mexc extends mexcRest {
     authenticate(subscriptionHash: any, params?: {}): Promise<string>;
     keepAliveListenKey(listenKey: any, params?: {}): Promise<void>;
     handlePong(client: Client, message: any): any;
-    handleSubscriptionStatus(client: Client, message: any): any;
-    handleMessage(client: Client, message: any): any;
+    handleSubscriptionStatus(client: Client, message: any): void;
+    handleMessage(client: Client, message: any): void;
     ping(client: any): {
         method: string;
     };

package/js/src/pro/mexc.js

@@ -1109,7 +1109,7 @@ export default class mexc extends mexcRest {
         //
         const msg = this.safeString(message, 'msg');
         if (msg === 'PONG') {
-            return this.handlePong(client, message);
+            this.handlePong(client, message);
         }
         else if (msg.indexOf('@') > -1) {
             const parts = msg.split('@');
@@ -1132,7 +1132,8 @@ export default class mexc extends mexcRest {
             return;
         }
         if ('msg' in message) {
-            return this.handleSubscriptionStatus(client, message);
+            this.handleSubscriptionStatus(client, message);
+            return;
         }
         const c = this.safeString(message, 'c');
         let channel = undefined;

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

@@ -11,8 +11,8 @@ export default class ndax extends ndaxRest {
     watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     handleOHLCV(client: Client, message: any): void;
     watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
-    handleOrderBook(client: Client, message: any): any;
+    handleOrderBook(client: Client, message: any): void;
     handleOrderBookSubscription(client: Client, message: any, subscription: any): void;
-    handleSubscriptionStatus(client: Client, message: any): any;
-    handleMessage(client: Client, message: any): any;
+    handleSubscriptionStatus(client: Client, message: any): void;
+    handleMessage(client: Client, message: any): void;
 }

package/js/src/pro/ndax.js

@@ -388,13 +388,13 @@ export default class ndax extends ndaxRest {
         const firstBidAsk = this.safeValue(payload, 0, []);
         const marketId = this.safeString(firstBidAsk, 7);
         if (marketId === undefined) {
-            return message;
+            return;
         }
         const market = this.safeMarket(marketId);
         const symbol = market['symbol'];
         const orderbook = this.safeValue(this.orderbooks, symbol);
         if (orderbook === undefined) {
-            return message;
+            return;
         }
         let timestamp = undefined;
         let nonce = undefined;
@@ -488,11 +488,8 @@ export default class ndax extends ndaxRest {
         const subscription = this.safeValue(subscriptionsById, id);
         if (subscription !== undefined) {
             const method = this.safeValue(subscription, 'method');
-            if (method === undefined) {
-                return message;
-            }
-            else {
-                return method.call(this, client, message, subscription);
+            if (method !== undefined) {
+                method.call(this, client, message, subscription);
             }
         }
     }
@@ -521,7 +518,7 @@ export default class ndax extends ndaxRest {
         //
         const payload = this.safeString(message, 'o');
         if (payload === undefined) {
-            return message;
+            return;
         }
         message['o'] = JSON.parse(payload);
         const methods = {
@@ -536,11 +533,8 @@ export default class ndax extends ndaxRest {
         };
         const event = this.safeString(message, 'n');
         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/js/src/pro/okcoin.d.ts

@@ -26,5 +26,5 @@ export default class okcoin extends okcoinRest {
     ping(client: any): string;
     handlePong(client: Client, message: any): any;
     handleErrorMessage(client: Client, message: any): any;
-    handleMessage(client: Client, message: any): any;
+    handleMessage(client: Client, message: any): void;
 }