ccxt 4.2.30 → 4.2.34

package/js/src/pro/blockchaincom.js

@@ -102,7 +102,7 @@ export default class blockchaincom extends blockchaincomRest {
         //
         const event = this.safeString(message, 'event');
         if (event === 'subscribed') {
-            return message;
+            return;
         }
         const result = { 'info': message };
         const balances = this.safeValue(message, 'balances', []);
@@ -172,11 +172,9 @@ export default class blockchaincom extends blockchaincomRest {
         //     }
         //
         const event = this.safeString(message, 'event');
-        if (event === 'subscribed') {
-            return message;
-        }
-        else if (event === 'rejected') {
-            throw new ExchangeError(this.id + ' ' + this.json(message));
+        if (event === 'rejected') {
+            const jsonMessage = this.json(message);
+            throw new ExchangeError(this.id + ' ' + jsonMessage);
         }
         else if (event === 'updated') {
             const marketId = this.safeString(message, 'symbol');
@@ -196,7 +194,7 @@ export default class blockchaincom extends blockchaincomRest {
             stored.append(ohlcv);
             client.resolve(stored, messageHash);
         }
-        else {
+        else if (event !== 'subscribed') {
             throw new NotSupported(this.id + ' ' + this.json(message));
         }
     }
@@ -258,7 +256,7 @@ export default class blockchaincom extends blockchaincomRest {
         const symbol = market['symbol'];
         let ticker = undefined;
         if (event === 'subscribed') {
-            return message;
+            return;
         }
         else if (event === 'snapshot') {
             ticker = this.parseTicker(message, market);
@@ -357,7 +355,7 @@ export default class blockchaincom extends blockchaincomRest {
         //
         const event = this.safeString(message, 'event');
         if (event !== 'updated') {
-            return message;
+            return;
         }
         const marketId = this.safeString(message, 'symbol');
         const symbol = this.safeSymbol(marketId);
@@ -519,7 +517,7 @@ export default class blockchaincom extends blockchaincomRest {
             this.orders = new ArrayCacheBySymbolById(limit);
         }
         if (event === 'subscribed') {
-            return message;
+            return;
         }
         else if (event === 'rejected') {
             throw new ExchangeError(this.id + ' ' + this.json(message));
@@ -689,30 +687,30 @@ export default class blockchaincom extends blockchaincomRest {
         const messageHash = 'orderbook:' + symbol + ':' + type;
         const datetime = this.safeString(message, 'timestamp');
         const timestamp = this.parse8601(datetime);
-        let storedOrderBook = this.safeValue(this.orderbooks, symbol);
-        if (storedOrderBook === undefined) {
-            storedOrderBook = this.countedOrderBook({});
-            this.orderbooks[symbol] = storedOrderBook;
+        let orderbook = this.safeValue(this.orderbooks, symbol);
+        if (orderbook === undefined) {
+            orderbook = this.countedOrderBook({});
+            this.orderbooks[symbol] = orderbook;
         }
         if (event === 'subscribed') {
-            return message;
+            return;
         }
         else if (event === 'snapshot') {
             const snapshot = this.parseOrderBook(message, symbol, timestamp, 'bids', 'asks', 'px', 'qty', 'num');
-            storedOrderBook.reset(snapshot);
+            orderbook.reset(snapshot);
         }
         else if (event === 'updated') {
             const asks = this.safeValue(message, 'asks', []);
             const bids = this.safeValue(message, 'bids', []);
-            this.handleDeltas(storedOrderBook['asks'], asks);
-            this.handleDeltas(storedOrderBook['bids'], bids);
-            storedOrderBook['timestamp'] = timestamp;
-            storedOrderBook['datetime'] = datetime;
+            this.handleDeltas(orderbook['asks'], asks);
+            this.handleDeltas(orderbook['bids'], bids);
+            orderbook['timestamp'] = timestamp;
+            orderbook['datetime'] = datetime;
         }
         else {
             throw new NotSupported(this.id + ' watchOrderBook() does not support ' + event + ' yet');
         }
-        client.resolve(storedOrderBook, messageHash);
+        client.resolve(orderbook, messageHash);
     }
     handleDelta(bookside, delta) {
         const bookArray = this.parseBidAsk(delta, 'px', 'qty', 'num');
@@ -753,7 +751,8 @@ export default class blockchaincom extends blockchaincomRest {
         };
         const handler = this.safeValue(handlers, channel);
         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));
     }
@@ -775,7 +774,7 @@ export default class blockchaincom extends blockchaincomRest {
             future.resolve(true);
         }
     }
-    authenticate(params = {}) {
+    async authenticate(params = {}) {
         const url = this.urls['api']['ws'];
         const client = this.client(url);
         const messageHash = 'authenticated';

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

@@ -25,11 +25,11 @@ export default class bybit extends bybitRest {
     watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleMyTrades(client: Client, message: any): void;
     watchPositions(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<Position[]>;
-    setPositionsCache(client: Client, symbols?: Strings): any;
+    setPositionsCache(client: Client, symbols?: Strings): void;
     loadPositionsSnapshot(client: any, messageHash: any): Promise<void>;
     handlePositions(client: any, message: any): void;
     watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
-    handleOrder(client: Client, message: any, subscription?: any): void;
+    handleOrder(client: Client, message: any): void;
     parseWsSpotOrder(order: any, market?: any): Order;
     watchBalance(params?: {}): Promise<Balances>;
     handleBalance(client: Client, message: any): void;

package/js/src/pro/bybit.js

@@ -909,7 +909,7 @@ export default class bybit extends bybitRest {
          * @name bybit#watchPositions
          * @see https://bybit-exchange.github.io/docs/v5/websocket/private/position
          * @description watch all open positions
-         * @param {string[]|undefined} symbols list of unified market symbols
+         * @param {string[]} [symbols] list of unified market symbols
          * @param {object} params extra parameters specific to the exchange API endpoint
          * @returns {object[]} a list of [position structure]{@link https://docs.ccxt.com/en/latest/manual.html#position-structure}
          */
@@ -942,7 +942,7 @@ export default class bybit extends bybitRest {
     }
     setPositionsCache(client, symbols = undefined) {
         if (this.positions !== undefined) {
-            return this.positions;
+            return;
         }
         const fetchPositionsSnapshot = this.handleOption('watchPositions', 'fetchPositionsSnapshot', true);
         if (fetchPositionsSnapshot) {
@@ -1075,7 +1075,7 @@ export default class bybit extends bybitRest {
         }
         return this.filterBySymbolSinceLimit(orders, symbol, since, limit, true);
     }
-    handleOrder(client, message, subscription = undefined) {
+    handleOrder(client, message) {
         //
         //     spot
         //     {
@@ -1641,7 +1641,7 @@ export default class bybit extends bybitRest {
         const authenticated = this.safeValue(client.subscriptions, messageHash);
         if (authenticated === undefined) {
             const expiresInt = this.milliseconds() + 10000;
-            const expires = expiresInt.toString();
+            const expires = this.numberToString(expiresInt);
             const path = 'GET/realtime';
             const auth = path + expires;
             const signature = this.hmac(this.encode(auth), this.encode(this.secret), sha256, 'hex');
@@ -1654,7 +1654,7 @@ export default class bybit extends bybitRest {
             const message = this.extend(request, params);
             this.watch(url, messageHash, message, messageHash);
         }
-        return future;
+        return await future;
     }
     handleErrorMessage(client, message) {
         //

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

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

package/js/src/pro/cex.js

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

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

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

package/js/src/pro/coinbase.js

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

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

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

package/js/src/pro/coinbasepro.js

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

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

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

package/js/src/pro/coinex.js

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

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

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

package/js/src/pro/currencycom.js

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

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

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

package/js/src/pro/deribit.js

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

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

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

package/js/src/pro/exmo.js

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

package/js/src/pro/gate.js

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

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

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

package/js/src/pro/gemini.js

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

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

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

package/js/src/pro/hitbtc.js

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