ccxt 4.2.9 → 4.2.11

package/js/src/deribit.js

@@ -1726,27 +1726,18 @@ export default class deribit extends Exchange {
          * @param {string} symbol unified symbol of the market to create an order in
          * @param {string} type 'market' or 'limit'
          * @param {string} side 'buy' or 'sell'
-         * @param {float} amount how much of currency you want to trade. For perpetual and futures the amount is in USD. For options it is in corresponding cryptocurrency contracts currency.
+         * @param {float} amount how much you want to trade in units of the base currency. For inverse perpetual and futures the amount is in the quote currency USD. For options it is in the underlying assets base currency.
          * @param {float} [price] the price at which the order is to be fullfilled, in units of the quote currency, ignored in market orders
          * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {string} [params.trigger] the trigger type 'index_price', 'mark_price', or 'last_price', default is 'last_price'
+         * @param {float} [params.trailingAmount] the quote amount to trail away from the current market price
          * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
          */
         await this.loadMarkets();
         const market = this.market(symbol);
-        if (market['inverse']) {
-            amount = this.amountToPrecision(symbol, amount);
-        }
-        else if (market['settle'] === 'USDC') {
-            amount = this.amountToPrecision(symbol, amount);
-        }
-        else {
-            amount = this.currencyToPrecision(symbol, amount);
-        }
         const request = {
             'instrument_name': market['id'],
-            // for perpetual and futures the amount is in USD
-            // for options it is in corresponding cryptocurrency contracts, e.g., BTC or ETH
-            'amount': amount,
+            'amount': this.amountToPrecision(symbol, amount),
             'type': type, // limit, stop_limit, market, stop_market, default is limit
             // 'label': 'string', // user-defined label for the order (maximum 64 characters)
             // 'price': this.priceToPrecision (symbol, 123.45), // only for limit and stop_limit orders
@@ -1759,12 +1750,15 @@ export default class deribit extends Exchange {
             // 'trigger': 'index_price', // mark_price, last_price, required for stop_limit orders
             // 'advanced': 'usd', // 'implv', advanced option order type, options only
         };
+        const trigger = this.safeString(params, 'trigger', 'last_price');
         const timeInForce = this.safeStringUpper(params, 'timeInForce');
         const reduceOnly = this.safeValue2(params, 'reduceOnly', 'reduce_only');
         // only stop loss sell orders are allowed when price crossed from above
         const stopLossPrice = this.safeValue(params, 'stopLossPrice');
         // only take profit buy orders are allowed when price crossed from below
         const takeProfitPrice = this.safeValue(params, 'takeProfitPrice');
+        const trailingAmount = this.safeString2(params, 'trailingAmount', 'trigger_offset');
+        const isTrailingAmountOrder = trailingAmount !== undefined;
         const isStopLimit = type === 'stop_limit';
         const isStopMarket = type === 'stop_market';
         const isTakeLimit = type === 'take_limit';
@@ -1786,10 +1780,15 @@ export default class deribit extends Exchange {
         else {
             request['type'] = 'market';
         }
-        if (isStopOrder) {
+        if (isTrailingAmountOrder) {
+            request['trigger'] = trigger;
+            request['type'] = 'trailing_stop';
+            request['trigger_offset'] = this.parseToNumeric(trailingAmount);
+        }
+        else if (isStopOrder) {
             const triggerPrice = (stopLossPrice !== undefined) ? stopLossPrice : takeProfitPrice;
             request['trigger_price'] = this.priceToPrecision(symbol, triggerPrice);
-            request['trigger'] = 'last_price'; // required
+            request['trigger'] = trigger;
             if (isStopLossOrder) {
                 if (isMarketOrder) {
                     // stop_market (sell only)
@@ -1829,7 +1828,7 @@ export default class deribit extends Exchange {
                 request['time_in_force'] = 'fill_or_kill';
             }
         }
-        params = this.omit(params, ['timeInForce', 'stopLossPrice', 'takeProfitPrice', 'postOnly', 'reduceOnly']);
+        params = this.omit(params, ['timeInForce', 'stopLossPrice', 'takeProfitPrice', 'postOnly', 'reduceOnly', 'trailingAmount']);
         let response = undefined;
         if (this.capitalize(side) === 'Buy') {
             response = await this.privateGetBuy(this.extend(request, params));
@@ -1896,25 +1895,43 @@ export default class deribit extends Exchange {
         return this.parseOrder(order, market);
     }
     async editOrder(id, symbol, type, side, amount = undefined, price = undefined, params = {}) {
+        /**
+         * @method
+         * @name deribit#editOrder
+         * @description edit a trade order
+         * @see https://docs.deribit.com/#private-edit
+         * @param {string} id edit order id
+         * @param {string} [symbol] unified symbol of the market to edit an order in
+         * @param {string} [type] 'market' or 'limit'
+         * @param {string} [side] 'buy' or 'sell'
+         * @param {float} amount how much you want to trade in units of the base currency, inverse swap and future use the quote currency
+         * @param {float} [price] the price at which the order is to be fullfilled, in units of the base currency, ignored in market orders
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {float} [params.trailingAmount] the quote amount to trail away from the current market price
+         * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
         if (amount === undefined) {
             throw new ArgumentsRequired(this.id + ' editOrder() requires an amount argument');
         }
-        if (price === undefined) {
-            throw new ArgumentsRequired(this.id + ' editOrder() requires a price argument');
-        }
         await this.loadMarkets();
         const request = {
             'order_id': id,
-            // for perpetual and futures the amount is in USD
-            // for options it is in corresponding cryptocurrency contracts, e.g., BTC or ETH
             'amount': this.amountToPrecision(symbol, amount),
-            'price': this.priceToPrecision(symbol, price), // required
             // 'post_only': false, // if the new price would cause the order to be filled immediately (as taker), the price will be changed to be just below the spread.
             // 'reject_post_only': false, // if true the order is put to order book unmodified or request is rejected
             // 'reduce_only': false, // if true, the order is intended to only reduce a current position
             // 'stop_price': false, // stop price, required for stop_limit orders
             // 'advanced': 'usd', // 'implv', advanced option order type, options only
         };
+        if (price !== undefined) {
+            request['price'] = this.priceToPrecision(symbol, price);
+        }
+        const trailingAmount = this.safeString2(params, 'trailingAmount', 'trigger_offset');
+        const isTrailingAmountOrder = trailingAmount !== undefined;
+        if (isTrailingAmountOrder) {
+            request['trigger_offset'] = this.parseToNumeric(trailingAmount);
+            params = this.omit(params, 'trigger_offset');
+        }
         const response = await this.privateGetEdit(this.extend(request, params));
         const result = this.safeValue(response, 'result', {});
         const order = this.safeValue(result, 'order');

package/js/src/kraken.d.ts

@@ -1,5 +1,5 @@
 import Exchange from './abstract/kraken.js';
-import type { Int, OrderSide, OrderType, OHLCV, Trade, Order, Balances, Str, Transaction, Ticker, OrderBook, Tickers, Strings, Currency, Market } from './base/types.js';
+import type { IndexType, Int, OrderSide, OrderType, OHLCV, Trade, Order, Balances, Str, Transaction, Ticker, OrderBook, Tickers, Strings, Currency, Market } from './base/types.js';
 /**
  * @class kraken
  * @augments Exchange
@@ -27,7 +27,7 @@ export default class kraken extends Exchange {
         percentage: boolean;
         tierBased: boolean;
     };
-    parseBidAsk(bidask: any, priceKey?: number, amountKey?: number): number[];
+    parseBidAsk(bidask: any, priceKey?: IndexType, amountKey?: IndexType, countOrIdKey?: IndexType): number[];
     fetchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     parseTicker(ticker: any, market?: Market): Ticker;
     fetchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;

package/js/src/kraken.js

@@ -754,7 +754,7 @@ export default class kraken extends Exchange {
             'tierBased': true,
         };
     }
-    parseBidAsk(bidask, priceKey = 0, amountKey = 1) {
+    parseBidAsk(bidask, priceKey = 0, amountKey = 1, countOrIdKey = 2) {
         const price = this.safeNumber(bidask, priceKey);
         const amount = this.safeNumber(bidask, amountKey);
         const timestamp = this.safeInteger(bidask, 2);

package/js/src/kucoin.js

@@ -2422,7 +2422,7 @@ export default class kucoin extends Exchange {
         //         }
         //    }
         const responseData = this.safeValue(response, 'data', {});
-        const orders = this.safeValue(responseData, 'items', []);
+        const orders = this.safeValue(responseData, 'items', responseData);
         return this.parseOrders(orders, market, since, limit);
     }
     async fetchClosedOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
@@ -3448,10 +3448,12 @@ export default class kucoin extends Exchange {
          * @name kucoin#fetchBalance
          * @description query for balance and get the amount of funds available for trading or funds locked in orders
          * @see https://docs.kucoin.com/#list-accounts
+         * @see https://www.kucoin.com/docs/rest/account/basic-info/get-account-list-spot-margin-trade_hf
          * @see https://docs.kucoin.com/#query-isolated-margin-account-info
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @param {object} [params.marginMode] 'cross' or 'isolated', margin type for fetching margin balance
          * @param {object} [params.type] extra parameters specific to the exchange API endpoint
+         * @param {object} [params.hf] *default if false* if true, the result includes the balance of the high frequency account
          * @returns {object} a [balance structure]{@link https://docs.ccxt.com/#/?id=balance-structure}
          */
         await this.loadMarkets();
@@ -3463,8 +3465,13 @@ export default class kucoin extends Exchange {
         const defaultType = this.safeString2(this.options, 'fetchBalance', 'defaultType', 'spot');
         const requestedType = this.safeString(params, 'type', defaultType);
         const accountsByType = this.safeValue(this.options, 'accountsByType');
-        const type = this.safeString(accountsByType, requestedType, requestedType);
+        let type = this.safeString(accountsByType, requestedType, requestedType);
         params = this.omit(params, 'type');
+        const isHf = this.safeValue(params, 'hf', false);
+        if (isHf) {
+            type = 'trade_hf';
+        }
+        params = this.omit(params, 'hf');
         const [marginMode, query] = this.handleMarginModeAndParams('fetchBalance', params);
         let response = undefined;
         const request = {};
@@ -3546,7 +3553,7 @@ export default class kucoin extends Exchange {
             'datetime': undefined,
         };
         if (isolated) {
-            const assets = this.safeValue(data, 'assets', []);
+            const assets = this.safeValue(data, 'assets', data);
             for (let i = 0; i < assets.length; i++) {
                 const entry = assets[i];
                 const marketId = this.safeString(entry, 'symbol');
@@ -3877,12 +3884,14 @@ export default class kucoin extends Exchange {
          * @method
          * @name kucoin#fetchLedger
          * @see https://docs.kucoin.com/#get-account-ledgers
+         * @see https://www.kucoin.com/docs/rest/account/basic-info/get-account-ledgers-trade_hf
+         * @see https://www.kucoin.com/docs/rest/account/basic-info/get-account-ledgers-margin_hf
          * @description fetch the history of changes, actions done by the user or operations that altered balance of the user
-         * @see https://docs.kucoin.com/#get-account-ledgers
          * @param {string} code unified currency code, default is undefined
          * @param {int} [since] timestamp in ms of the earliest ledger entry, default is undefined
          * @param {int} [limit] max number of ledger entrys to return, default is undefined
          * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {boolean} [params.hf] default false, when true will fetch ledger entries for the high frequency trading account
          * @param {int} [params.until] the latest time in ms to fetch entries for
          * @param {boolean} [params.paginate] default false, when true will automatically paginate by calling this endpoint multiple times. See in the docs all the [availble parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
          * @returns {object} a [ledger structure]{@link https://docs.ccxt.com/#/?id=ledger-structure}
@@ -3891,6 +3900,8 @@ export default class kucoin extends Exchange {
         await this.loadAccounts();
         let paginate = false;
         [paginate, params] = this.handleOptionAndParams(params, 'fetchLedger', 'paginate');
+        const isHf = this.safeValue(params, 'hf');
+        params = this.omit(params, 'hf');
         if (paginate) {
             return await this.fetchPaginatedCallDynamic('fetchLedger', code, since, limit, params);
         }
@@ -3911,7 +3922,20 @@ export default class kucoin extends Exchange {
             request['currency'] = currency['id'];
         }
         [request, params] = this.handleUntilOption('endAt', request, params);
-        const response = await this.privateGetAccountsLedgers(this.extend(request, params));
+        let marginMode = undefined;
+        [marginMode, params] = this.handleMarginModeAndParams('fetchLedger', params);
+        let response = undefined;
+        if (isHf) {
+            if (marginMode !== undefined) {
+                response = await this.privateGetHfMarginAccountLedgers(this.extend(request, params));
+            }
+            else {
+                response = await this.privateGetHfAccountsLedgers(this.extend(request, params));
+            }
+        }
+        else {
+            response = await this.privateGetAccountsLedgers(this.extend(request, params));
+        }
         //
         //     {
         //         "code":"200000",
@@ -3950,7 +3974,7 @@ export default class kucoin extends Exchange {
         //     }
         //
         const data = this.safeValue(response, 'data');
-        const items = this.safeValue(data, 'items');
+        const items = this.safeValue(data, 'items', data);
         return this.parseLedger(items, currency, since, limit);
     }
     calculateRateLimiterCost(api, method, path, params, config = {}) {

package/js/src/lykke.d.ts

@@ -1,5 +1,5 @@
 import Exchange from './abstract/lykke.js';
-import type { Balances, Currency, Int, Market, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction } from './base/types.js';
+import type { IndexType, Balances, Currency, Int, Market, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction } from './base/types.js';
 /**
  * @class lykke
  * @augments Exchange
@@ -25,7 +25,7 @@ export default class lykke extends Exchange {
     fetchOpenOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchClosedOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     fetchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
-    parseBidAsk(bidask: any, priceKey?: number, amountKey?: number): number[];
+    parseBidAsk(bidask: any, priceKey?: IndexType, amountKey?: IndexType, countOrIdKey?: IndexType): number[];
     fetchDepositAddress(code: string, params?: {}): Promise<{
         currency: string;
         address: string;

package/js/src/lykke.js

@@ -1081,7 +1081,7 @@ export default class lykke extends Exchange {
         //
         return this.parseTrades(payload, market, since, limit);
     }
-    parseBidAsk(bidask, priceKey = 0, amountKey = 1) {
+    parseBidAsk(bidask, priceKey = 0, amountKey = 1, countOrIdKey = 2) {
         const price = this.safeString(bidask, priceKey);
         const amount = Precise.stringAbs(this.safeString(bidask, amountKey));
         return [this.parseNumber(price), this.parseNumber(amount)];

package/js/src/ndax.d.ts

@@ -1,5 +1,5 @@
 import Exchange from './abstract/ndax.js';
-import type { Balances, Currency, Int, Market, OHLCV, Order, OrderBook, OrderSide, OrderType, Str, Ticker, Trade, Transaction } from './base/types.js';
+import type { IndexType, Balances, Currency, Int, Market, OHLCV, Order, OrderBook, OrderSide, OrderType, Str, Ticker, Trade, Transaction } from './base/types.js';
 /**
  * @class ndax
  * @augments Exchange
@@ -10,7 +10,7 @@ export default class ndax extends Exchange {
     fetchCurrencies(params?: {}): Promise<{}>;
     fetchMarkets(params?: {}): Promise<import("./base/types.js").MarketInterface[]>;
     parseMarket(market: any): Market;
-    parseOrderBook(orderbook: any, symbol: any, timestamp?: any, bidsKey?: string, asksKey?: string, priceKey?: number, amountKey?: number): OrderBook;
+    parseOrderBook(orderbook: any, symbol: any, timestamp?: any, bidsKey?: string, asksKey?: string, priceKey?: IndexType, amountKey?: IndexType, countOrIdKey?: IndexType): OrderBook;
     fetchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     parseTicker(ticker: any, market?: Market): Ticker;
     fetchTicker(symbol: string, params?: {}): Promise<Ticker>;

package/js/src/ndax.js

@@ -521,7 +521,7 @@ export default class ndax extends Exchange {
             'info': market,
         };
     }
-    parseOrderBook(orderbook, symbol, timestamp = undefined, bidsKey = 'bids', asksKey = 'asks', priceKey = 6, amountKey = 8) {
+    parseOrderBook(orderbook, symbol, timestamp = undefined, bidsKey = 'bids', asksKey = 'asks', priceKey = 6, amountKey = 8, countOrIdKey = 2) {
         let nonce = undefined;
         const result = {
             'symbol': symbol,

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

@@ -22,6 +22,7 @@ export default class bitmart extends bitmartRest {
     handleTrade(client: Client, message: any): any;
     parseWsTrade(trade: any, market?: Market): Trade;
     handleTicker(client: Client, message: any): any;
+    resolveMessageHashesForSymbol(client: any, symbol: any, result: any, prexif: any): void;
     parseWsSwapTicker(ticker: any, market?: Market): Ticker;
     watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
     handleOHLCV(client: Client, message: any): void;

package/js/src/pro/bitmart.js

@@ -293,25 +293,39 @@ export default class bitmart extends bitmartRest {
         const market = this.getMarketFromSymbols(symbols);
         let type = 'spot';
         [type, params] = this.handleMarketTypeAndParams('watchTickers', market, params);
-        symbols = this.marketSymbols(symbols);
-        if (type === 'spot') {
-            throw new NotSupported(this.id + ' watchTickers() does not support ' + type + ' markets. Use watchTicker() instead');
-        }
         const url = this.implodeHostname(this.urls['api']['ws'][type]['public']);
-        if (type === 'swap') {
-            type = 'futures';
-        }
-        let messageHash = 'tickers';
+        symbols = this.marketSymbols(symbols);
+        let messageHash = 'tickers::' + type;
         if (symbols !== undefined) {
             messageHash += '::' + symbols.join(',');
         }
-        const request = {
-            'action': 'subscribe',
-            'args': ['futures/ticker'],
-        };
-        const newTickers = await this.watch(url, messageHash, this.deepExtend(request, params), messageHash);
+        let request = undefined;
+        let tickers = undefined;
+        const isSpot = (type === 'spot');
+        if (isSpot) {
+            if (symbols === undefined) {
+                throw new ArgumentsRequired(this.id + ' watchTickers() for ' + type + ' market type requires symbols argument to be provided');
+            }
+            const marketIds = this.marketIds(symbols);
+            const finalArray = [];
+            for (let i = 0; i < marketIds.length; i++) {
+                finalArray.push('spot/ticker:' + marketIds[i]);
+            }
+            request = {
+                'op': 'subscribe',
+                'args': finalArray,
+            };
+            tickers = await this.watch(url, messageHash, this.deepExtend(request, params), messageHash);
+        }
+        else {
+            request = {
+                'action': 'subscribe',
+                'args': ['futures/ticker'],
+            };
+            tickers = await this.watch(url, messageHash, this.deepExtend(request, params), messageHash);
+        }
         if (this.newUpdates) {
-            return newTickers;
+            return tickers;
         }
         return this.filterByArray(this.tickers, 'symbol', symbols);
     }
@@ -896,28 +910,36 @@ export default class bitmart extends bitmartRest {
                 const messageHash = table + ':' + marketId;
                 this.tickers[symbol] = ticker;
                 client.resolve(ticker, messageHash);
+                this.resolveMessageHashesForSymbol(client, symbol, ticker, 'tickers::');
             }
         }
         else {
+            // on each update for contract markets, single ticker is provided
             const ticker = this.parseWsSwapTicker(data);
             const symbol = this.safeString(ticker, 'symbol');
             this.tickers[symbol] = ticker;
-            client.resolve(ticker, 'tickers');
-            const messageHashes = this.findMessageHashes(client, 'tickers::');
-            for (let i = 0; i < messageHashes.length; i++) {
-                const messageHash = messageHashes[i];
-                const parts = messageHash.split('::');
-                const symbolsString = parts[1];
-                const symbols = symbolsString.split(',');
-                if (this.inArray(symbol, symbols)) {
-                    const response = {};
-                    response[symbol] = ticker;
-                    client.resolve(response, messageHash);
-                }
-            }
+            client.resolve(ticker, 'tickers::swap');
+            this.resolveMessageHashesForSymbol(client, symbol, ticker, 'tickers::');
         }
         return message;
     }
+    resolveMessageHashesForSymbol(client, symbol, result, prexif) {
+        const prefixSeparator = '::';
+        const symbolsSeparator = ',';
+        const messageHashes = this.findMessageHashes(client, prexif);
+        for (let i = 0; i < messageHashes.length; i++) {
+            const messageHash = messageHashes[i];
+            const parts = messageHash.split(prefixSeparator);
+            const length = parts.length;
+            const symbolsString = parts[length - 1];
+            const symbols = symbolsString.split(symbolsSeparator);
+            if (this.inArray(symbol, symbols)) {
+                const response = {};
+                response[symbol] = result;
+                client.resolve(response, messageHash);
+            }
+        }
+    }
     parseWsSwapTicker(ticker, market = undefined) {
         //
         //    {

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

@@ -1,5 +1,5 @@
 import blockchaincomRest from '../blockchaincom.js';
-import type { IndexType, Int, Str, OrderBook, Order, Trade, Ticker, OHLCV, Balances } from '../base/types.js';
+import type { Int, Str, OrderBook, Order, Trade, Ticker, OHLCV, Balances } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class blockchaincom extends blockchaincomRest {
     describe(): any;
@@ -19,16 +19,6 @@ export default class blockchaincom extends blockchaincomRest {
     parseWsOrderStatus(status: any): string;
     watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     handleOrderBook(client: Client, message: any): any;
-    parseCountedBidAsk(bidAsk: any, priceKey?: IndexType, amountKey?: IndexType, countKey?: IndexType): number[];
-    parseCountedBidsAsks(bidasks: any, priceKey?: IndexType, amountKey?: IndexType, countKey?: IndexType): any[];
-    parseCountedOrderBook(orderbook: any, symbol: string, timestamp?: Int, bidsKey?: IndexType, asksKey?: IndexType, priceKey?: IndexType, amountKey?: IndexType, countKey?: IndexType): {
-        symbol: string;
-        bids: any;
-        asks: any;
-        timestamp: number;
-        datetime: string;
-        nonce: any;
-    };
     handleDelta(bookside: any, delta: any): void;
     handleDeltas(bookside: any, deltas: any): void;
     checkSequenceNumber(client: Client, message: any): void;

package/js/src/pro/blockchaincom.js

@@ -698,7 +698,7 @@ export default class blockchaincom extends blockchaincomRest {
             return message;
         }
         else if (event === 'snapshot') {
-            const snapshot = this.parseCountedOrderBook(message, symbol, timestamp, 'bids', 'asks', 'px', 'qty', 'num');
+            const snapshot = this.parseOrderBook(message, symbol, timestamp, 'bids', 'asks', 'px', 'qty', 'num');
             storedOrderBook.reset(snapshot);
         }
         else if (event === 'updated') {
@@ -714,34 +714,8 @@ export default class blockchaincom extends blockchaincomRest {
         }
         client.resolve(storedOrderBook, messageHash);
     }
-    parseCountedBidAsk(bidAsk, priceKey = 0, amountKey = 1, countKey = 2) {
-        const price = this.safeNumber(bidAsk, priceKey);
-        const amount = this.safeNumber(bidAsk, amountKey);
-        const count = this.safeNumber(bidAsk, countKey);
-        return [price, amount, count];
-    }
-    parseCountedBidsAsks(bidasks, priceKey = 0, amountKey = 1, countKey = 2) {
-        bidasks = this.toArray(bidasks);
-        const result = [];
-        for (let i = 0; i < bidasks.length; i++) {
-            result.push(this.parseCountedBidAsk(bidasks[i], priceKey, amountKey, countKey));
-        }
-        return result;
-    }
-    parseCountedOrderBook(orderbook, symbol, timestamp = undefined, bidsKey = 'bids', asksKey = 'asks', priceKey = 0, amountKey = 1, countKey = 2) {
-        const bids = this.parseCountedBidsAsks(this.safeValue(orderbook, bidsKey, []), priceKey, amountKey, countKey);
-        const asks = this.parseCountedBidsAsks(this.safeValue(orderbook, asksKey, []), priceKey, amountKey, countKey);
-        return {
-            'symbol': symbol,
-            'bids': this.sortBy(bids, 0, true),
-            'asks': this.sortBy(asks, 0),
-            'timestamp': timestamp,
-            'datetime': this.iso8601(timestamp),
-            'nonce': undefined,
-        };
-    }
     handleDelta(bookside, delta) {
-        const bookArray = this.parseCountedBidAsk(delta, 'px', 'qty', 'num');
+        const bookArray = this.parseBidAsk(delta, 'px', 'qty', 'num');
         bookside.storeArray(bookArray);
     }
     handleDeltas(bookside, deltas) {

package/js/src/pro/coinbasepro.js

@@ -92,7 +92,7 @@ export default class coinbasepro extends coinbaseproRest {
             const symbol = symbols[i];
             market = this.market(symbol);
             productIds.push(market['id']);
-            messageHashes.push(messageHashStart + ':' + market['id']);
+            messageHashes.push(messageHashStart + ':' + market['symbol']);
         }
         let url = this.urls['api']['ws'];
         if ('signature' in params) {
@@ -137,10 +137,12 @@ export default class coinbasepro extends coinbaseproRest {
             throw new BadSymbol(this.id + ' watchTickers requires a non-empty symbols array');
         }
         const channel = 'ticker';
-        const messageHash = 'tickers::';
-        const newTickers = await this.subscribeMultiple(channel, symbols, messageHash, params);
+        const messageHash = 'ticker';
+        const ticker = await this.subscribeMultiple(channel, symbols, messageHash, params);
         if (this.newUpdates) {
-            return newTickers;
+            const result = {};
+            result[ticker['symbol']] = ticker;
+            return result;
         }
         return this.filterByArray(this.tickers, 'symbol', symbols);
     }
@@ -752,19 +754,10 @@ export default class coinbasepro extends coinbaseproRest {
             const ticker = this.parseTicker(message);
             const symbol = ticker['symbol'];
             this.tickers[symbol] = ticker;
-            const type = this.safeString(message, 'type');
-            const messageHash = type + ':' + marketId;
+            const messageHash = 'ticker:' + symbol;
+            const idMessageHash = 'ticker:' + marketId;
             client.resolve(ticker, messageHash);
-            const messageHashes = this.findMessageHashes(client, 'tickers::');
-            for (let i = 0; i < messageHashes.length; i++) {
-                const currentMessageHash = messageHashes[i];
-                const parts = currentMessageHash.split('::');
-                const symbolsString = parts[1];
-                const symbols = symbolsString.split(',');
-                if (this.inArray(symbol, symbols)) {
-                    client.resolve(ticker, currentMessageHash);
-                }
-            }
+            client.resolve(ticker, idMessageHash);
         }
         return message;
     }

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

@@ -6,7 +6,9 @@ export default class cryptocom extends cryptocomRest {
     pong(client: any, message: any): Promise<void>;
     watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     watchOrderBookForSymbols(symbols: string[], limit?: Int, params?: {}): Promise<OrderBook>;
-    handleOrderBookSnapshot(client: Client, message: any): void;
+    handleDelta(bookside: any, delta: any): void;
+    handleDeltas(bookside: any, deltas: any): void;
+    handleOrderBook(client: Client, message: any): void;
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     watchTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleTrades(client: Client, message: any): void;