ccxt 4.2.30 → 4.2.34

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

package/js/src/pro/okcoin.js

@@ -478,7 +478,7 @@ export default class okcoin extends okcoinRest {
             };
             this.spawn(this.watch, url, messageHash, request, messageHash, future);
         }
-        return await future;
+        return future;
     }
     async watchBalance(params = {}) {
         /**
@@ -711,7 +711,8 @@ export default class okcoin extends okcoinRest {
         // }
         //
         if (message === 'pong') {
-            return this.handlePong(client, message);
+            this.handlePong(client, message);
+            return;
         }
         const table = this.safeString(message, 'table');
         if (table === undefined) {
@@ -724,11 +725,8 @@ export default class okcoin extends okcoinRest {
                     'subscribe': this.handleSubscriptionStatus,
                 };
                 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);
                 }
             }
         }
@@ -750,11 +748,8 @@ export default class okcoin extends okcoinRest {
             if (name.indexOf('candle') >= 0) {
                 method = this.handleOHLCV;
             }
-            if (method === undefined) {
-                return message;
-            }
-            else {
-                return method.call(this, client, message);
+            if (method !== undefined) {
+                method.call(this, client, message);
             }
         }
     }

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

@@ -43,5 +43,5 @@ export default class okx extends okxRest {
     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;
 }

package/js/src/pro/okx.js

@@ -758,7 +758,7 @@ export default class okx extends okxRest {
             const message = this.extend(request, params);
             this.watch(url, messageHash, message, messageHash);
         }
-        return future;
+        return await future;
     }
     async watchBalance(params = {}) {
         /**
@@ -1564,7 +1564,8 @@ export default class okx extends okxRest {
         //
         //
         if (message === 'pong') {
-            return this.handlePong(client, message);
+            this.handlePong(client, message);
+            return;
         }
         // const table = this.safeString (message, 'table');
         // if (table === undefined) {
@@ -1583,11 +1584,8 @@ export default class okx extends okxRest {
                 'mass-cancel': 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);
             }
         }
         else {
@@ -1615,12 +1613,9 @@ export default class okx extends okxRest {
                 if (channel.indexOf('candle') === 0) {
                     this.handleOHLCV(client, message);
                 }
-                else {
-                    return message;
-                }
             }
             else {
-                return method.call(this, client, message);
+                method.call(this, client, message);
             }
         }
     }

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

@@ -28,7 +28,7 @@ export default class onetrading extends onetradingRest {
     handleSubscriptions(client: Client, message: any): any;
     handleHeartbeat(client: Client, message: any): any;
     handleErrorMessage(client: Client, message: any): void;
-    handleMessage(client: Client, message: any): any;
+    handleMessage(client: Client, message: any): void;
     handlePricePointUpdates(client: Client, message: any): any;
     handleAuthenticationMessage(client: Client, message: any): any;
     watchMany(messageHash: any, request: any, subscriptionHash: any, symbols?: Strings, params?: {}): Promise<any>;

package/js/src/pro/onetrading.js

@@ -365,26 +365,26 @@ export default class onetrading extends onetradingRest {
         const dateTime = this.safeString(message, 'time');
         const timestamp = this.parse8601(dateTime);
         const channel = 'book:' + symbol;
-        let storedOrderBook = this.safeValue(this.orderbooks, symbol);
-        if (storedOrderBook === undefined) {
-            storedOrderBook = this.orderBook({});
+        let orderbook = this.safeValue(this.orderbooks, symbol);
+        if (orderbook === undefined) {
+            orderbook = this.orderBook({});
         }
         if (type === 'ORDER_BOOK_SNAPSHOT') {
             const snapshot = this.parseOrderBook(message, symbol, timestamp, 'bids', 'asks');
-            storedOrderBook.reset(snapshot);
+            orderbook.reset(snapshot);
         }
         else if (type === 'ORDER_BOOK_UPDATE') {
             const changes = this.safeValue(message, 'changes', []);
-            this.handleDeltas(storedOrderBook, changes);
+            this.handleDeltas(orderbook, changes);
         }
         else {
             throw new NotSupported(this.id + ' watchOrderBook() did not recognize message type ' + type);
         }
-        storedOrderBook['nonce'] = timestamp;
-        storedOrderBook['timestamp'] = timestamp;
-        storedOrderBook['datetime'] = this.iso8601(timestamp);
-        this.orderbooks[symbol] = storedOrderBook;
-        client.resolve(storedOrderBook, channel);
+        orderbook['nonce'] = timestamp;
+        orderbook['timestamp'] = timestamp;
+        orderbook['datetime'] = this.iso8601(timestamp);
+        this.orderbooks[symbol] = orderbook;
+        client.resolve(orderbook, channel);
     }
     handleDelta(orderbook, delta) {
         //
@@ -970,13 +970,14 @@ export default class onetrading extends onetradingRest {
             if (updateType === 'ORDER_CLOSED' && filled === 0) {
                 status = 'canceled';
             }
-            orders.append({
+            const orderObject = {
                 'id': orderId,
                 'symbol': symbol,
                 'status': status,
                 'timestamp': this.parse8601(datetime),
                 'datetime': datetime,
-            });
+            };
+            orders.append(orderObject);
         }
         else {
             const parsed = this.parseOrder(update);
@@ -1213,7 +1214,8 @@ export default class onetrading extends onetradingRest {
     handleMessage(client, message) {
         const error = this.safeValue(message, 'error');
         if (error !== undefined) {
-            return this.handleErrorMessage(client, message);
+            this.handleErrorMessage(client, message);
+            return;
         }
         const type = this.safeValue(message, 'type');
         const handlers = {
@@ -1244,9 +1246,8 @@ export default class onetrading extends onetradingRest {
         };
         const handler = this.safeValue(handlers, type);
         if (handler !== undefined) {
-            return handler.call(this, client, message);
+            handler.call(this, client, message);
         }
-        throw new NotSupported(this.id + ' no handler found for this message ' + this.json(message));
     }
     handlePricePointUpdates(client, message) {
         //

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

@@ -12,7 +12,7 @@ export default class p2b extends p2bRest {
     handleTrade(client: Client, message: any): any;
     handleTicker(client: Client, message: any): any;
     handleOrderBook(client: Client, message: any): void;
-    handleMessage(client: Client, message: any): any;
+    handleMessage(client: Client, message: any): void;
     handleErrorMessage(client: Client, message: any): boolean;
     ping(client: any): {
         method: string;

package/js/src/pro/p2b.js

@@ -365,7 +365,8 @@ export default class p2b extends p2bRest {
                 const bid = this.safeValue(bids, i);
                 const price = this.safeNumber(bid, 0);
                 const amount = this.safeNumber(bid, 1);
-                orderbook['bids'].store(price, amount);
+                const bookSide = orderbook['bids'];
+                bookSide.store(price, amount);
             }
         }
         if (asks !== undefined) {
@@ -373,7 +374,8 @@ export default class p2b extends p2bRest {
                 const ask = this.safeValue(asks, i);
                 const price = this.safeNumber(ask, 0);
                 const amount = this.safeNumber(ask, 1);
-                orderbook['asks'].store(price, amount);
+                const bookside = orderbook['asks'];
+                bookside.store(price, amount);
             }
         }
         orderbook['symbol'] = symbol;
@@ -398,7 +400,7 @@ export default class p2b extends p2bRest {
         };
         const endpoint = this.safeValue(methods, method);
         if (endpoint !== undefined) {
-            return endpoint.call(this, client, message);
+            endpoint.call(this, client, message);
         }
     }
     handleErrorMessage(client, message) {

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

@@ -61,15 +61,15 @@ export default class phemex extends phemexRest {
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
-    handleDelta(bookside: any, delta: any, market?: any): void;
-    handleDeltas(bookside: any, deltas: any, market?: any): void;
+    customHandleDelta(bookside: any, delta: any, market?: any): void;
+    customHandleDeltas(bookside: any, deltas: any, market?: any): void;
     handleOrderBook(client: Client, message: any): void;
     watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleMyTrades(client: Client, message: any): void;
     watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     handleOrders(client: Client, message: any): void;
     parseWSSwapOrder(order: any, market?: any): Order;
-    handleMessage(client: Client, message: any): any;
+    handleMessage(client: Client, message: any): void;
     handleAuthenticate(client: Client, message: any): void;
     subscribePrivate(type: any, messageHash: any, params?: {}): Promise<any>;
     authenticate(params?: {}): Promise<any>;

package/js/src/pro/phemex.js

@@ -633,13 +633,13 @@ export default class phemex extends phemexRest {
         }
         return this.filterBySinceLimit(ohlcv, since, limit, 0, true);
     }
-    handleDelta(bookside, delta, market = undefined) {
+    customHandleDelta(bookside, delta, market = undefined) {
         const bidAsk = this.customParseBidAsk(delta, 0, 1, market);
         bookside.storeArray(bidAsk);
     }
-    handleDeltas(bookside, deltas, market = undefined) {
+    customHandleDeltas(bookside, deltas, market = undefined) {
         for (let i = 0; i < deltas.length; i++) {
-            this.handleDelta(bookside, deltas[i], market);
+            this.customHandleDelta(bookside, deltas[i], market);
         }
     }
     handleOrderBook(client, message) {
@@ -709,8 +709,8 @@ export default class phemex extends phemexRest {
                 const changes = this.safeValue2(message, 'book', 'orderbook_p', {});
                 const asks = this.safeValue(changes, 'asks', []);
                 const bids = this.safeValue(changes, 'bids', []);
-                this.handleDeltas(orderbook['asks'], asks, market);
-                this.handleDeltas(orderbook['bids'], bids, market);
+                this.customHandleDeltas(orderbook['asks'], asks, market);
+                this.customHandleDeltas(orderbook['bids'], bids, market);
                 orderbook['nonce'] = nonce;
                 orderbook['timestamp'] = timestamp;
                 orderbook['datetime'] = this.iso8601(timestamp);
@@ -1406,21 +1406,26 @@ export default class phemex extends phemexRest {
             const method = client.subscriptions[id];
             delete client.subscriptions[id];
             if (method !== true) {
-                return method.call(this, client, message);
+                method.call(this, client, message);
+                return;
             }
         }
         const methodName = this.safeString(message, 'method', '');
         if (('market24h' in message) || ('spot_market24h' in message) || (methodName.indexOf('perp_market24h_pack_p') >= 0)) {
-            return this.handleTicker(client, message);
+            this.handleTicker(client, message);
+            return;
         }
         else if (('trades' in message) || ('trades_p' in message)) {
-            return this.handleTrades(client, message);
+            this.handleTrades(client, message);
+            return;
         }
         else if (('kline' in message) || ('kline_p' in message)) {
-            return this.handleOHLCV(client, message);
+            this.handleOHLCV(client, message);
+            return;
         }
         else if (('book' in message) || ('orderbook_p' in message)) {
-            return this.handleOrderBook(client, message);
+            this.handleOrderBook(client, message);
+            return;
         }
         if (('orders' in message) || ('orders_p' in message)) {
             const orders = this.safeValue2(message, 'orders', 'orders_p', {});
@@ -1507,6 +1512,6 @@ export default class phemex extends phemexRest {
             future = this.watch(url, messageHash, message);
             client.subscriptions[messageHash] = future;
         }
-        return await future;
+        return future;
     }
 }

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

@@ -33,7 +33,7 @@ export default class poloniex extends poloniexRest {
     parseWsBalance(response: any): Balances;
     handleMyTrades(client: Client, parsedTrade: any): void;
     handlePong(client: Client): void;
-    handleMessage(client: Client, message: any): any;
+    handleMessage(client: Client, message: any): void;
     handleErrorMessage(client: Client, message: any): boolean;
     handleAuthenticate(client: Client, message: any): any;
     ping(client: any): {

package/js/src/pro/poloniex.js

@@ -1042,7 +1042,8 @@ export default class poloniex extends poloniexRest {
                         const bid = this.safeValue(bids, j);
                         const price = this.safeNumber(bid, 0);
                         const amount = this.safeNumber(bid, 1);
-                        orderbook['bids'].store(price, amount);
+                        const bidsSide = orderbook['bids'];
+                        bidsSide.store(price, amount);
                     }
                 }
                 if (asks !== undefined) {
@@ -1050,7 +1051,8 @@ export default class poloniex extends poloniexRest {
                         const ask = this.safeValue(asks, j);
                         const price = this.safeNumber(ask, 0);
                         const amount = this.safeNumber(ask, 1);
-                        orderbook['asks'].store(price, amount);
+                        const asksSide = orderbook['asks'];
+                        asksSide.store(price, amount);
                     }
                 }
                 orderbook['symbol'] = symbol;
@@ -1184,14 +1186,14 @@ export default class poloniex extends poloniexRest {
                 this.handleErrorMessage(client, item);
             }
             else {
-                return this.handleOrderRequest(client, message);
+                this.handleOrderRequest(client, message);
             }
         }
         else {
             const data = this.safeValue(message, 'data', []);
             const dataLength = data.length;
             if (dataLength > 0) {
-                return method.call(this, client, message);
+                method.call(this, client, message);
             }
         }
     }

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

@@ -3,7 +3,7 @@ import type { Int, Str, OrderBook, Order, Trade, Ticker, Balances } from '../bas
 import Client from '../base/ws/Client.js';
 export default class poloniexfutures extends poloniexfuturesRest {
     describe(): any;
-    negotiate(privateChannel: any, params?: {}): any;
+    negotiate(privateChannel: any, params?: {}): Promise<any>;
     negotiateHelper(privateChannel: any, params?: {}): Promise<string>;
     requestId(): any;
     subscribe(name: string, isPrivate: boolean, symbol?: Str, subscription?: any, params?: {}): Promise<any>;
@@ -24,7 +24,7 @@ export default class poloniexfutures extends poloniexfuturesRest {
     parseOrderStatus(status: string, type: string): string;
     parseWsOrder(order: any, market?: any): Order;
     handleTicker(client: Client, message: any): any;
-    handleL3OrderBook(client: Client, message: any): any;
+    handleL3OrderBook(client: Client, message: any): void;
     handleLevel2(client: Client, message: any): void;
     handleL2OrderBook(client: Client, message: any): void;
     handeL2Snapshot(client: Client, message: any): void;
@@ -34,13 +34,13 @@ export default class poloniexfutures extends poloniexfuturesRest {
     handleBalance(client: Client, message: any): any;
     parseWsBalance(response: any): Balances;
     handleSystemStatus(client: Client, message: any): any;
-    handleSubject(client: Client, message: any): any;
+    handleSubject(client: Client, message: any): void;
     ping(client: Client): {
         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;
     handleAuthenticate(client: any, message: any): any;
 }

package/js/src/pro/poloniexfutures.js

@@ -4,7 +4,6 @@
 // https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code
 // EDIT THE CORRESPONDENT .ts FILE INSTEAD
 
-'use strict';
 //  ---------------------------------------------------------------------------
 import poloniexfuturesRest from '../poloniexfutures.js';
 import { AuthenticationError, BadRequest, ExchangeError } from '../base/errors.js';
@@ -64,18 +63,21 @@ export default class poloniexfutures extends poloniexfuturesRest {
             },
         });
     }
-    negotiate(privateChannel, params = {}) {
+    async negotiate(privateChannel, params = {}) {
         const connectId = privateChannel ? 'private' : 'public';
         const urls = this.safeValue(this.options, 'urls', {});
         if (connectId in urls) {
-            return urls[connectId];
+            // return urls[connectId];
+            const storedFuture = urls[connectId];
+            return await storedFuture;
         }
         // 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;
@@ -713,7 +715,7 @@ export default class poloniexfutures extends poloniexfuturesRest {
         const messageHash = this.safeString(message, 'topic');
         const subject = this.safeString(message, 'subject');
         if (subject === 'received') {
-            return message;
+            return;
         }
         // At the time of writting this, there is no implementation to easily convert each order into the orderbook so raw messages are returned
         client.resolve(message, messageHash);
@@ -732,9 +734,10 @@ export default class poloniexfutures extends poloniexfuturesRest {
         const topic = this.safeString(message, 'topic');
         const isSnapshot = topic.indexOf('Depth') >= 0;
         if (isSnapshot) {
-            return this.handeL2Snapshot(client, message);
+            this.handeL2Snapshot(client, message);
+            return;
         }
-        return this.handleL2OrderBook(client, message);
+        this.handleL2OrderBook(client, message);
     }
     handleL2OrderBook(client, message) {
         //
@@ -771,7 +774,7 @@ export default class poloniexfutures extends poloniexfuturesRest {
             const snapshotDelay = this.handleOption('watchOrderBook', 'snapshotDelay', 5);
             if (cacheLength === snapshotDelay) {
                 const limit = 0;
-                this.spawn(this.loadOrderBook, client, messageHash, symbol, limit);
+                this.spawn(this.loadOrderBook, client, messageHash, symbol, limit, {});
             }
             orderBook.cache.push(data);
             return;
@@ -959,7 +962,7 @@ export default class poloniexfutures extends poloniexfuturesRest {
         };
         const method = this.safeValue(methods, subject);
         if (method !== undefined) {
-            return method.call(this, client, message);
+            method.call(this, client, message);
         }
     }
     ping(client) {
@@ -995,7 +998,7 @@ export default class poloniexfutures extends poloniexfuturesRest {
         };
         const method = this.safeValue(methods, type);
         if (method !== undefined) {
-            return method.call(this, client, message);
+            method.call(this, client, message);
         }
     }
     handleAuthenticate(client, message) {

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

@@ -22,6 +22,6 @@ export default class probit extends probitRest {
     handleErrorMessage(client: Client, message: any): void;
     handleAuthenticate(client: Client, message: any): void;
     handleMarketData(client: Client, message: any): void;
-    handleMessage(client: Client, message: any): any;
+    handleMessage(client: Client, message: any): void;
     authenticate(params?: {}): Promise<any>;
 }