ccxt 4.2.8 → 4.2.10

package/js/src/bitmart.js

@@ -6,7 +6,7 @@
 
 //  ---------------------------------------------------------------------------
 import Exchange from './abstract/bitmart.js';
-import { AuthenticationError, ExchangeNotAvailable, AccountSuspended, PermissionDenied, RateLimitExceeded, InvalidNonce, InvalidAddress, ArgumentsRequired, ExchangeError, InvalidOrder, InsufficientFunds, BadRequest, OrderNotFound, BadSymbol, NotSupported } from './base/errors.js';
+import { AuthenticationError, ExchangeNotAvailable, OnMaintenance, AccountSuspended, PermissionDenied, RateLimitExceeded, InvalidNonce, InvalidAddress, ArgumentsRequired, ExchangeError, InvalidOrder, InsufficientFunds, BadRequest, OrderNotFound, BadSymbol, NotSupported } from './base/errors.js';
 import { Precise } from './base/Precise.js';
 import { TICK_SIZE, TRUNCATE } from './base/functions/number.js';
 import { sha256 } from './static_dependencies/noble-hashes/sha256.js';
@@ -309,7 +309,11 @@ export default class bitmart extends Exchange {
                     '30012': AuthenticationError,
                     '30013': RateLimitExceeded,
                     '30014': ExchangeNotAvailable,
-                    // funding account errors
+                    '30016': OnMaintenance,
+                    '30017': RateLimitExceeded,
+                    '30018': BadRequest,
+                    '30019': PermissionDenied,
+                    // funding account & sub account errors
                     '60000': BadRequest,
                     '60001': BadRequest,
                     '60002': BadRequest,
@@ -326,13 +330,31 @@ export default class bitmart extends Exchange {
                     '60020': PermissionDenied,
                     '60021': PermissionDenied,
                     '60022': PermissionDenied,
+                    '60026': PermissionDenied,
+                    '60027': PermissionDenied,
+                    '60028': AccountSuspended,
+                    '60029': AccountSuspended,
                     '60030': BadRequest,
                     '60031': BadRequest,
                     '60050': ExchangeError,
                     '60051': ExchangeError,
                     '61001': InsufficientFunds,
                     '61003': BadRequest,
-                    // spot errors
+                    '61004': BadRequest,
+                    '61005': BadRequest,
+                    '61006': NotSupported,
+                    '61007': ExchangeError,
+                    '61008': ExchangeError,
+                    // spot public errors
+                    '70000': ExchangeError,
+                    '70001': BadRequest,
+                    '70002': BadSymbol,
+                    '71001': BadRequest,
+                    '71002': BadRequest,
+                    '71003': BadRequest,
+                    '71004': BadRequest,
+                    '71005': BadRequest,
+                    // spot & margin errors
                     '50000': BadRequest,
                     '50001': BadSymbol,
                     '50002': BadRequest,
@@ -352,26 +374,75 @@ export default class bitmart extends Exchange {
                     '50016': BadRequest,
                     '50017': BadRequest,
                     '50018': BadRequest,
-                    '50019': BadRequest,
-                    '51004': InsufficientFunds,
-                    // '50019': ExchangeError, // 400, Invalid status. validate status is [1=Failed, 2=Success, 3=Frozen Failed, 4=Frozen Success, 5=Partially Filled, 6=Fully Fulled, 7=Canceling, 8=Canceled
+                    '50019': ExchangeError,
                     '50020': InsufficientFunds,
                     '50021': BadRequest,
                     '50022': ExchangeNotAvailable,
                     '50023': BadSymbol,
+                    '50024': BadRequest,
+                    '50025': BadRequest,
+                    '50026': BadRequest,
+                    '50027': BadRequest,
+                    '50028': BadRequest,
                     '50029': InvalidOrder,
-                    '50030': InvalidOrder,
+                    '50030': OrderNotFound,
+                    '50031': OrderNotFound,
                     '50032': OrderNotFound,
+                    '50033': InvalidOrder,
                     // below Error codes used interchangeably for both failed postOnly and IOC orders depending on market price and order side
-                    '50035': InvalidOrder,
                     '50034': InvalidOrder,
+                    '50035': InvalidOrder,
+                    '50036': ExchangeError,
+                    '50037': BadRequest,
+                    '50038': BadRequest,
+                    '50039': BadRequest,
+                    '50040': BadSymbol,
+                    '50041': ExchangeError,
+                    '50042': BadRequest,
+                    '51000': BadSymbol,
+                    '51001': ExchangeError,
+                    '51002': ExchangeError,
+                    '51003': ExchangeError,
+                    '51004': InsufficientFunds,
+                    '51005': InvalidOrder,
+                    '51006': InvalidOrder,
+                    '51007': BadRequest,
+                    '51008': ExchangeError,
+                    '51009': InvalidOrder,
+                    '51010': InvalidOrder,
                     '51011': InvalidOrder,
+                    '51012': InvalidOrder,
+                    '51013': InvalidOrder,
+                    '51014': InvalidOrder,
+                    '51015': InvalidOrder,
+                    '52000': BadRequest,
+                    '52001': BadRequest,
+                    '52002': BadRequest,
+                    '52003': BadRequest,
+                    '52004': BadRequest,
                     '53000': AccountSuspended,
                     '53001': AccountSuspended,
+                    '53002': PermissionDenied,
+                    '53003': PermissionDenied,
+                    '53005': PermissionDenied,
+                    '53006': PermissionDenied,
+                    '53007': PermissionDenied,
+                    '53008': PermissionDenied,
+                    '53009': PermissionDenied,
+                    '53010': PermissionDenied,
                     '57001': BadRequest,
                     '58001': BadRequest,
                     '59001': ExchangeError,
                     '59002': ExchangeError,
+                    '59003': ExchangeError,
+                    '59004': ExchangeError,
+                    '59005': PermissionDenied,
+                    '59006': ExchangeError,
+                    '59007': ExchangeError,
+                    '59008': ExchangeError,
+                    '59009': ExchangeError,
+                    '59010': InsufficientFunds,
+                    '59011': ExchangeError,
                     // contract errors
                     '40001': ExchangeError,
                     '40002': ExchangeError,
@@ -407,14 +478,22 @@ export default class bitmart extends Exchange {
                     '40032': InvalidOrder,
                     '40033': InvalidOrder,
                     '40034': BadSymbol,
-                    '53002': PermissionDenied,
-                    '53003': PermissionDenied,
-                    '53005': PermissionDenied,
-                    '53006': PermissionDenied,
-                    '53007': PermissionDenied,
-                    '53008': PermissionDenied,
-                    '53009': PermissionDenied,
-                    '53010': PermissionDenied, // 403 This account is restricted from borrowing
+                    '40035': OrderNotFound,
+                    '40036': InvalidOrder,
+                    '40037': OrderNotFound,
+                    '40038': BadRequest,
+                    '40039': BadRequest,
+                    '40040': InvalidOrder,
+                    '40041': InvalidOrder,
+                    '40042': InvalidOrder,
+                    '40043': InvalidOrder,
+                    '40044': InvalidOrder,
+                    '40045': InvalidOrder,
+                    '40046': PermissionDenied,
+                    '40047': PermissionDenied,
+                    '40048': BadRequest,
+                    '40049': BadRequest,
+                    '40050': InvalidOrder, // 403, Client OrderId duplicated with existing orders
                 },
                 'broad': {},
             },

package/js/src/bl3p.d.ts

@@ -1,5 +1,5 @@
 import Exchange from './abstract/bl3p.js';
-import type { Balances, Int, Market, OrderBook, OrderSide, OrderType, Str, Ticker, Trade } from './base/types.js';
+import type { Balances, Int, Market, OrderBook, OrderSide, OrderType, Str, Ticker, Trade, IndexType } from './base/types.js';
 /**
  * @class bl3p
  * @augments Exchange
@@ -8,7 +8,7 @@ export default class bl3p extends Exchange {
     describe(): any;
     parseBalance(response: any): Balances;
     fetchBalance(params?: {}): Promise<Balances>;
-    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;
     fetchTicker(symbol: string, params?: {}): Promise<Ticker>;

package/js/src/bl3p.js

@@ -149,7 +149,7 @@ export default class bl3p extends Exchange {
         const response = await this.privatePostGENMKTMoneyInfo(params);
         return this.parseBalance(response);
     }
-    parseBidAsk(bidask, priceKey = 0, amountKey = 1) {
+    parseBidAsk(bidask, priceKey = 0, amountKey = 1, countOrIdKey = 2) {
         const price = this.safeString(bidask, priceKey);
         const size = this.safeString(bidask, amountKey);
         return [

package/js/src/btcalpha.d.ts

@@ -1,5 +1,5 @@
 import Exchange from './abstract/btcalpha.js';
-import type { Balances, Currency, Int, Market, OHLCV, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction } from './base/types.js';
+import type { IndexType, Balances, Currency, Int, Market, OHLCV, Order, OrderBook, OrderSide, OrderType, Str, Strings, Ticker, Tickers, Trade, Transaction } from './base/types.js';
 /**
  * @class btcalpha
  * @augments Exchange
@@ -12,7 +12,7 @@ export default class btcalpha extends Exchange {
     fetchTicker(symbol: string, params?: {}): Promise<Ticker>;
     parseTicker(ticker: any, market?: Market): Ticker;
     fetchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
-    parseBidsAsks(bidasks: any, priceKey?: number, amountKey?: number): any[];
+    parseBidsAsks(bidasks: any, priceKey?: IndexType, amountKey?: IndexType, countOrIdKey?: IndexType): any[];
     parseTrade(trade: any, market?: Market): Trade;
     fetchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     fetchDeposits(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Transaction[]>;

package/js/src/btcalpha.js

@@ -362,7 +362,7 @@ export default class btcalpha extends Exchange {
         const response = await this.publicGetOrderbookPairName(this.extend(request, params));
         return this.parseOrderBook(response, market['symbol'], undefined, 'buy', 'sell', 'price', 'amount');
     }
-    parseBidsAsks(bidasks, priceKey = 0, amountKey = 1) {
+    parseBidsAsks(bidasks, priceKey = 0, amountKey = 1, countOrIdKey = 2) {
         const result = [];
         for (let i = 0; i < bidasks.length; i++) {
             const bidask = bidasks[i];

package/js/src/cryptocom.js

@@ -773,6 +773,7 @@ export default class cryptocom extends Exchange {
         //                     "p": "26386.00",
         //                     "q": "0.00453",
         //                     "t": 1686944282062,
+        //                     "tn" : 1704476468851524373,
         //                     "d": "4611686018455979970",
         //                     "i": "BTC_USD"
         //                 },
@@ -1943,7 +1944,8 @@ export default class cryptocom extends Exchange {
         //         "s": "sell",
         //         "p": "26386.00",
         //         "q": "0.00453",
-        //         "t": 1686944282062,
+        //         "tn": 1686944282062,
+        //         "tn": 1704476468851524373,
         //         "d": "4611686018455979970",
         //         "i": "BTC_USD"
         //     }

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 = {}) {

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/binance.js

@@ -867,7 +867,10 @@ export default class binance extends binanceRest {
         name = this.safeString(params, 'name', name);
         params = this.omit(params, 'name');
         let wsParams = [];
-        const messageHash = 'tickers';
+        let messageHash = 'tickers';
+        if (symbols !== undefined) {
+            messageHash = 'tickers::' + symbols.join(',');
+        }
         if (name === 'bookTicker') {
             if (marketIds === undefined) {
                 throw new ArgumentsRequired(this.id + ' watchTickers() requires symbols for bookTicker');
@@ -1060,6 +1063,19 @@ export default class binance extends binanceRest {
             this.tickers[symbol] = result;
             newTickers.push(result);
         }
+        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(',');
+            const tickers = this.filterByArray(newTickers, 'symbol', symbols);
+            const tickersSymbols = Object.keys(tickers);
+            const numTickers = tickersSymbols.length;
+            if (numTickers > 0) {
+                client.resolve(tickers, messageHash);
+            }
+        }
         client.resolve(newTickers, 'tickers');
     }
     signParams(params = {}) {

package/js/src/pro/bitget.js

@@ -156,7 +156,9 @@ export default class bitget extends bitgetRest {
         }
         const tickers = await this.watchPublicMultiple(messageHashes, topics, params);
         if (this.newUpdates) {
-            return tickers;
+            const result = {};
+            result[tickers['symbol']] = tickers;
+            return result;
         }
         return this.filterByArray(this.tickers, 'symbol', symbols);
     }

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,22 +293,39 @@ export default class bitmart extends bitmartRest {
         const market = this.getMarketFromSymbols(symbols);
         let type = 'spot';
         [type, params] = this.handleMarketTypeAndParams('watchTickers', market, params);
+        const url = this.implodeHostname(this.urls['api']['ws'][type]['public']);
         symbols = this.marketSymbols(symbols);
-        if (type === 'spot') {
-            throw new NotSupported(this.id + ' watchTickers() does not support ' + type + ' markets. Use watchTicker() instead');
+        let messageHash = 'tickers::' + type;
+        if (symbols !== undefined) {
+            messageHash += '::' + symbols.join(',');
         }
-        const url = this.implodeHostname(this.urls['api']['ws'][type]['public']);
-        if (type === 'swap') {
-            type = 'futures';
+        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);
         }
-        const messageHash = 'tickers';
-        const request = {
-            'action': 'subscribe',
-            'args': ['futures/ticker'],
-        };
-        const newTickers = await this.watch(url, messageHash, this.deepExtend(request, params), messageHash);
         if (this.newUpdates) {
-            return newTickers;
+            return tickers;
         }
         return this.filterByArray(this.tickers, 'symbol', symbols);
     }
@@ -707,7 +724,7 @@ export default class bitmart extends bitmartRest {
         //    }
         //
         const marketId = this.safeString(position, 'symbol');
-        market = this.safeMarket(marketId, market, '', 'swap');
+        market = this.safeMarket(marketId, market, undefined, 'swap');
         const symbol = market['symbol'];
         const openTimestamp = this.safeInteger(position, 'create_time');
         const timestamp = this.safeInteger(position, 'update_time');
@@ -893,16 +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');
+            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) {
         //
         //    {
@@ -1049,7 +1086,7 @@ export default class bitmart extends bitmartRest {
         }
         else {
             const marketId = this.safeString(data, 'symbol');
-            const market = this.safeMarket(marketId, undefined, '', 'swap');
+            const market = this.safeMarket(marketId, undefined, undefined, 'swap');
             const symbol = market['symbol'];
             const items = this.safeValue(data, 'items', []);
             this.ohlcvs[symbol] = this.safeValue(this.ohlcvs, symbol, {});

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;