ccxt 4.2.57 → 4.2.59

package/dist/cjs/src/coinbase.js

@@ -3065,10 +3065,12 @@ class coinbase extends coinbase$1 {
          * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
          */
         await this.loadMarkets();
+        const maxLimit = 300;
+        limit = (limit === undefined) ? maxLimit : Math.min(limit, maxLimit);
         let paginate = false;
         [paginate, params] = this.handleOptionAndParams(params, 'fetchOHLCV', 'paginate', false);
         if (paginate) {
-            return await this.fetchPaginatedCallDeterministic('fetchOHLCV', symbol, since, limit, timeframe, params, 299);
+            return await this.fetchPaginatedCallDeterministic('fetchOHLCV', symbol, since, limit, timeframe, params, maxLimit - 1);
         }
         const market = this.market(symbol);
         const request = {
@@ -3078,20 +3080,20 @@ class coinbase extends coinbase$1 {
         const until = this.safeValueN(params, ['until', 'till', 'end']);
         params = this.omit(params, ['until', 'till']);
         const duration = this.parseTimeframe(timeframe);
-        const candles300 = 300 * duration;
+        const requestedDuration = limit * duration;
         let sinceString = undefined;
         if (since !== undefined) {
             sinceString = this.numberToString(this.parseToInt(since / 1000));
         }
         else {
             const now = this.seconds().toString();
-            sinceString = Precise["default"].stringSub(now, candles300.toString());
+            sinceString = Precise["default"].stringSub(now, requestedDuration.toString());
         }
         request['start'] = sinceString;
         let endString = this.numberToString(until);
         if (until === undefined) {
             // 300 candles max
-            endString = Precise["default"].stringAdd(sinceString, candles300.toString());
+            endString = Precise["default"].stringAdd(sinceString, requestedDuration.toString());
         }
         request['end'] = endString;
         const response = await this.v3PrivateGetBrokerageProductsProductIdCandles(this.extend(request, params));
@@ -3151,8 +3153,19 @@ class coinbase extends coinbase$1 {
         const request = {
             'product_id': market['id'],
         };
+        if (since !== undefined) {
+            request['start'] = this.numberToString(this.parseToInt(since / 1000));
+        }
         if (limit !== undefined) {
-            request['limit'] = limit;
+            request['limit'] = Math.min(limit, 1000);
+        }
+        let until = undefined;
+        [until, params] = this.handleOptionAndParams(params, 'fetchTrades', 'until');
+        if (until !== undefined) {
+            request['end'] = this.numberToString(this.parseToInt(until / 1000));
+        }
+        else if (since !== undefined) {
+            throw new errors.ArgumentsRequired(this.id + ' fetchTrades() requires a `until` parameter when you use `since` argument');
         }
         const response = await this.v3PrivateGetBrokerageProductsProductIdTicker(this.extend(request, params));
         //
@@ -3286,7 +3299,7 @@ class coinbase extends coinbase$1 {
         //         }
         //     }
         //
-        const data = this.safeValue(response, 'pricebook', {});
+        const data = this.safeDict(response, 'pricebook', {});
         const time = this.safeString(data, 'time');
         const timestamp = this.parse8601(time);
         return this.parseOrderBook(data, symbol, timestamp, 'bids', 'asks', 'price', 'size');
@@ -3739,7 +3752,7 @@ class coinbase extends coinbase$1 {
             }
             else {
                 this.checkRequiredCredentials();
-                const nonce = this.nonce().toString();
+                const timestampString = this.seconds().toString();
                 let payload = '';
                 if (method !== 'GET') {
                     if (Object.keys(query).length) {
@@ -3747,17 +3760,14 @@ class coinbase extends coinbase$1 {
                         payload = body;
                     }
                 }
-                else {
-                    if (Object.keys(query).length) {
-                        payload += '?' + this.urlencode(query);
-                    }
-                }
-                const auth = nonce + method + savedPath + payload;
+                // 'GET' doesn't need payload in the signature. inside url is enough
+                // https://docs.cloud.coinbase.com/advanced-trade-api/docs/auth#example-request
+                const auth = timestampString + method + savedPath + payload;
                 const signature = this.hmac(this.encode(auth), this.encode(this.secret), sha256.sha256);
                 headers = {
                     'CB-ACCESS-KEY': this.apiKey,
                     'CB-ACCESS-SIGN': signature,
-                    'CB-ACCESS-TIMESTAMP': nonce,
+                    'CB-ACCESS-TIMESTAMP': timestampString,
                     'Content-Type': 'application/json',
                 };
             }

package/dist/cjs/src/currencycom.js

@@ -1806,12 +1806,22 @@ class currencycom extends currencycom$1 {
         };
         const response = await this.privateGetV2LeverageSettings(this.extend(request, params));
         //
-        // {
-        //     "values": [ 1, 2, 5, 10, ],
-        //     "value": "10",
-        // }
+        //     {
+        //         "values": [ 1, 2, 5, 10, ],
+        //         "value": "10",
+        //     }
         //
-        return this.safeNumber(response, 'value');
+        return this.parseLeverage(response, market);
+    }
+    parseLeverage(leverage, market = undefined) {
+        const leverageValue = this.safeInteger(leverage, 'value');
+        return {
+            'info': leverage,
+            'symbol': market['symbol'],
+            'marginMode': undefined,
+            'longLeverage': leverageValue,
+            'shortLeverage': leverageValue,
+        };
     }
     async fetchDepositAddress(code, params = {}) {
         /**

package/dist/cjs/src/delta.js

@@ -2811,6 +2811,7 @@ class delta extends delta$1 {
         const request = {
             'product_id': market['numericId'],
         };
+        const response = await this.privateGetProductsProductIdOrdersLeverage(this.extend(request, params));
         //
         //     {
         //         "result": {
@@ -2824,7 +2825,19 @@ class delta extends delta$1 {
         //         "success": true
         //     }
         //
-        return await this.privateGetProductsProductIdOrdersLeverage(this.extend(request, params));
+        const result = this.safeDict(response, 'result', {});
+        return this.parseLeverage(result, market);
+    }
+    parseLeverage(leverage, market = undefined) {
+        const marketId = this.safeString(leverage, 'index_symbol');
+        const leverageValue = this.safeInteger(leverage, 'leverage');
+        return {
+            'info': leverage,
+            'symbol': this.safeSymbol(marketId, market),
+            'marginMode': this.safeStringLower(leverage, 'margin_mode'),
+            'longLeverage': leverageValue,
+            'shortLeverage': leverageValue,
+        };
     }
     async setLeverage(leverage, symbol = undefined, params = {}) {
         /**

package/dist/cjs/src/gate.js

@@ -959,7 +959,7 @@ class gate extends gate$1 {
          * @param {object} [params] extra parameters specific to the exchange API endpoint
          * @returns {object[]} an array of objects representing market data
          */
-        const sandboxMode = this.safeValue(this.options, 'sandboxMode', false);
+        const sandboxMode = this.safeBool(this.options, 'sandboxMode', false);
         let rawPromises = [
             this.fetchContractMarkets(params),
             this.fetchOptionMarkets(params),

package/dist/cjs/src/hitbtc.js

@@ -3399,7 +3399,18 @@ class hitbtc extends hitbtc$1 {
         //         ]
         //     }
         //
-        return this.safeNumber(response, 'leverage');
+        return this.parseLeverage(response, market);
+    }
+    parseLeverage(leverage, market = undefined) {
+        const marketId = this.safeString(leverage, 'symbol');
+        const leverageValue = this.safeInteger(leverage, 'leverage');
+        return {
+            'info': leverage,
+            'symbol': this.safeSymbol(marketId, market),
+            'marginMode': this.safeStringLower(leverage, 'type'),
+            'longLeverage': leverageValue,
+            'shortLeverage': leverageValue,
+        };
     }
     async setLeverage(leverage, symbol = undefined, params = {}) {
         /**

package/dist/cjs/src/krakenfutures.js

@@ -2456,7 +2456,7 @@ class krakenfutures extends krakenfutures$1 {
         //
         return await this.privatePutLeveragepreferences(this.extend(request, params));
     }
-    async fetchLeverage(symbol = undefined, params = {}) {
+    async fetchLeverage(symbol, params = {}) {
         /**
          * @method
          * @name krakenfutures#fetchLeverage
@@ -2470,17 +2470,32 @@ class krakenfutures extends krakenfutures$1 {
             throw new errors.ArgumentsRequired(this.id + ' fetchLeverage() requires a symbol argument');
         }
         await this.loadMarkets();
+        const market = this.market(symbol);
         const request = {
             'symbol': this.marketId(symbol).toUpperCase(),
         };
+        const response = await this.privateGetLeveragepreferences(this.extend(request, params));
         //
-        //   {
-        //       "result": "success",
-        //       "serverTime": "2023-08-01T09:54:08.900Z",
-        //       "leveragePreferences": [ { symbol: "PF_LTCUSD", maxLeverage: "5.00" } ]
-        //   }
+        //     {
+        //         "result": "success",
+        //         "serverTime": "2023-08-01T09:54:08.900Z",
+        //         "leveragePreferences": [ { symbol: "PF_LTCUSD", maxLeverage: "5.00" } ]
+        //     }
         //
-        return await this.privateGetLeveragepreferences(this.extend(request, params));
+        const leveragePreferences = this.safeList(response, 'leveragePreferences', []);
+        const data = this.safeDict(leveragePreferences, 0, {});
+        return this.parseLeverage(data, market);
+    }
+    parseLeverage(leverage, market = undefined) {
+        const marketId = this.safeString(leverage, 'symbol');
+        const leverageValue = this.safeInteger(leverage, 'maxLeverage');
+        return {
+            'info': leverage,
+            'symbol': this.safeSymbol(marketId, market),
+            'marginMode': undefined,
+            'longLeverage': leverageValue,
+            'shortLeverage': leverageValue,
+        };
     }
     handleErrors(code, reason, url, method, headers, body, response, requestHeaders, requestBody) {
         if (response === undefined) {

package/dist/cjs/src/kuna.js

@@ -806,7 +806,7 @@ class kuna extends kuna$1 {
         await this.loadMarkets();
         const market = this.market(symbol);
         const request = {
-            'pair': market['id'],
+            'pairs': market['id'],
         };
         if (limit !== undefined) {
             request['limit'] = limit;
@@ -814,18 +814,21 @@ class kuna extends kuna$1 {
         const response = await this.v4PublicGetTradePublicBookPairs(this.extend(request, params));
         //
         //    {
-        //        "data": {
-        //            "id": "3e5591ba-2778-4d85-8851-54284045ea44",       // Unique identifier of a trade
-        //            "pair": "BTC_USDT",                                 // Market pair that is being traded
-        //            "quoteQuantity": "11528.8118",                      // Qty of the quote asset, USDT in this example
-        //            "matchPrice": "18649",                              // Exchange price at the moment of execution
-        //            "matchQuantity": "0.6182",                          // Qty of the base asset, BTC in this example
-        //            "createdAt": "2022-09-23T14:30:41.486Z",            // Date-time of trade execution, UTC
-        //            "side": "Ask"                                       // Trade type: `Ask` or `Bid`. Bid for buying base asset, Ask for selling base asset (e.g. for BTC_USDT trading pair, BTC is the base asset).
-        //        }
+        //        'data': [
+        //            {
+        //                'createdAt': '2024-03-02T00:10:49.385Z',
+        //                'id': '3b42878a-3688-4bc1-891e-5cc2fc902142',
+        //                'matchPrice': '62181.31',
+        //                'matchQuantity': '0.00568',
+        //                'pair': 'BTC_USDT',
+        //                'quoteQuantity': '353.1898408',
+        //                'side': 'Bid'
+        //            },
+        //            ...
+        //        ]
         //    }
         //
-        const data = this.safeValue(response, 'data', {});
+        const data = this.safeList(response, 'data', []);
         return this.parseTrades(data, market, since, limit);
     }
     parseTrade(trade, market = undefined) {

package/dist/cjs/src/lbank.js

@@ -2691,7 +2691,7 @@ class lbank extends lbank$1 {
             const uppercaseHash = hash.toUpperCase();
             let sign = undefined;
             if (signatureMethod === 'RSA') {
-                const cacheSecretAsPem = this.safeValue(this.options, 'cacheSecretAsPem', true);
+                const cacheSecretAsPem = this.safeBool(this.options, 'cacheSecretAsPem', true);
                 let pem = undefined;
                 if (cacheSecretAsPem) {
                     pem = this.safeValue(this.options, 'pem');

package/dist/cjs/src/mexc.js

@@ -5422,30 +5422,30 @@ class mexc extends mexc$1 {
         //     }
         //
         const data = this.safeList(response, 'data', []);
-        const longLeverage = this.safeDict(data, 0);
-        return this.parseLeverage(longLeverage, market);
+        return this.parseLeverage(data, market);
     }
     parseLeverage(leverage, market = undefined) {
-        //
-        //     {
-        //         "level": 1,
-        //         "maxVol": 463300,
-        //         "mmr": 0.004,
-        //         "imr": 0.005,
-        //         "positionType": 1,
-        //         "openType": 1,
-        //         "leverage": 20,
-        //         "limitBySys": false,
-        //         "currentMmr": 0.004
-        //     }
-        //
-        const marketId = this.safeString(leverage, 'symbol');
-        market = this.safeMarket(marketId, market, undefined, 'contract');
+        let marginMode = undefined;
+        let longLeverage = undefined;
+        let shortLeverage = undefined;
+        for (let i = 0; i < leverage.length; i++) {
+            const entry = leverage[i];
+            const openType = this.safeInteger(entry, 'openType');
+            const positionType = this.safeInteger(entry, 'positionType');
+            if (positionType === 1) {
+                longLeverage = this.safeInteger(entry, 'leverage');
+            }
+            else if (positionType === 2) {
+                shortLeverage = this.safeInteger(entry, 'leverage');
+            }
+            marginMode = (openType === 1) ? 'isolated' : 'cross';
+        }
         return {
             'info': leverage,
             'symbol': market['symbol'],
-            'leverage': this.safeInteger(leverage, 'leverage'),
-            'marginMode': undefined,
+            'marginMode': marginMode,
+            'longLeverage': longLeverage,
+            'shortLeverage': shortLeverage,
         };
     }
     handleMarginModeAndParams(methodName, params = {}, defaultValue = undefined) {
@@ -5496,7 +5496,7 @@ class mexc extends mexc$1 {
                     'source': this.safeString(this.options, 'broker', 'CCXT'),
                 };
             }
-            if ((method === 'POST') || (method === 'PUT')) {
+            if ((method === 'POST') || (method === 'PUT') || (method === 'DELETE')) {
                 headers['Content-Type'] = 'application/json';
             }
         }

package/dist/cjs/src/okx.js

@@ -1557,7 +1557,7 @@ class okx extends okx$1 {
         // while fetchCurrencies is a public API method by design
         // therefore we check the keys here
         // and fallback to generating the currencies from the markets
-        const isSandboxMode = this.safeValue(this.options, 'sandboxMode', false);
+        const isSandboxMode = this.safeBool(this.options, 'sandboxMode', false);
         if (!this.checkRequiredCredentials(false) || isSandboxMode) {
             return undefined;
         }
@@ -5161,7 +5161,37 @@ class okx extends okx$1 {
         //        "msg": ""
         //     }
         //
-        return response;
+        const data = this.safeList(response, 'data', []);
+        return this.parseLeverage(data, market);
+    }
+    parseLeverage(leverage, market = undefined) {
+        let marketId = undefined;
+        let marginMode = undefined;
+        let longLeverage = undefined;
+        let shortLeverage = undefined;
+        for (let i = 0; i < leverage.length; i++) {
+            const entry = leverage[i];
+            marginMode = this.safeStringLower(entry, 'mgnMode');
+            marketId = this.safeString(entry, 'instId');
+            const positionSide = this.safeStringLower(entry, 'posSide');
+            if (positionSide === 'long') {
+                longLeverage = this.safeInteger(entry, 'lever');
+            }
+            else if (positionSide === 'short') {
+                shortLeverage = this.safeInteger(entry, 'lever');
+            }
+            else {
+                longLeverage = this.safeInteger(entry, 'lever');
+                shortLeverage = this.safeInteger(entry, 'lever');
+            }
+        }
+        return {
+            'info': leverage,
+            'symbol': this.safeSymbol(marketId, market),
+            'marginMode': marginMode,
+            'longLeverage': longLeverage,
+            'shortLeverage': shortLeverage,
+        };
     }
     async fetchPosition(symbol, params = {}) {
         /**

package/dist/cjs/src/phemex.js

@@ -2419,7 +2419,7 @@ class phemex extends phemex$1 {
     }
     parseOrder(order, market = undefined) {
         const isSwap = this.safeBool(market, 'swap', false);
-        const hasPnl = ('closedPnl' in order);
+        const hasPnl = ('closedPnl' in order) || ('closedPnlRv' in order) || ('totalPnlRv' in order);
         if (isSwap || hasPnl) {
             return this.parseSwapOrder(order, market);
         }

package/dist/cjs/src/pro/alpaca.js

@@ -610,7 +610,7 @@ class alpaca extends alpaca$1 {
         for (let i = 0; i < message.length; i++) {
             const data = message[i];
             const T = this.safeString(data, 'T');
-            const msg = this.safeValue(data, 'msg', {});
+            const msg = this.safeString(data, 'msg');
             if (T === 'subscription') {
                 this.handleSubscription(client, data);
                 return;

package/dist/cjs/src/pro/binance.js

@@ -2465,7 +2465,7 @@ class binance extends binance$1 {
         this.setBalanceCache(client, type, isPortfolioMargin);
         this.setPositionsCache(client, type, symbols, isPortfolioMargin);
         const fetchPositionsSnapshot = this.handleOption('watchPositions', 'fetchPositionsSnapshot', true);
-        const awaitPositionsSnapshot = this.safeValue('watchPositions', 'awaitPositionsSnapshot', true);
+        const awaitPositionsSnapshot = this.safeBool('watchPositions', 'awaitPositionsSnapshot', true);
         const cache = this.safeValue(this.positions, type);
         if (fetchPositionsSnapshot && awaitPositionsSnapshot && cache === undefined) {
             const snapshot = await client.future(type + ':fetchPositionsSnapshot');

package/dist/cjs/src/pro/bitfinex2.js

@@ -53,7 +53,7 @@ class bitfinex2 extends bitfinex2$1 {
             'symbol': marketId,
         };
         const result = await this.watch(url, messageHash, this.deepExtend(request, params), messageHash, { 'checksum': false });
-        const checksum = this.safeValue(this.options, 'checksum', true);
+        const checksum = this.safeBool(this.options, 'checksum', true);
         if (checksum && !client.subscriptions[messageHash]['checksum'] && (channel === 'book')) {
             client.subscriptions[messageHash]['checksum'] = true;
             await client.send({

package/dist/cjs/src/pro/bitget.js

@@ -536,7 +536,7 @@ class bitget extends bitget$1 {
             this.handleDeltas(storedOrderBook['bids'], bids);
             storedOrderBook['timestamp'] = timestamp;
             storedOrderBook['datetime'] = this.iso8601(timestamp);
-            const checksum = this.safeValue(this.options, 'checksum', true);
+            const checksum = this.safeBool(this.options, 'checksum', true);
             const isSnapshot = this.safeString(message, 'action') === 'snapshot'; // snapshot does not have a checksum
             if (!isSnapshot && checksum) {
                 const storedAsks = storedOrderBook['asks'];

package/dist/cjs/src/pro/bitmart.js

@@ -107,11 +107,12 @@ class bitmart extends bitmart$1 {
         }
         return await this.watch(url, messageHash, this.deepExtend(request, params), messageHash);
     }
-    async subscribeMultiple(channel, type, symbols, params = {}) {
+    async subscribeMultiple(channel, type, symbols = undefined, params = {}) {
+        symbols = this.marketSymbols(symbols, type, false, true);
         const url = this.implodeHostname(this.urls['api']['ws'][type]['public']);
         const channelType = (type === 'spot') ? 'spot' : 'futures';
         const actionType = (type === 'spot') ? 'op' : 'action';
-        const rawSubscriptions = [];
+        let rawSubscriptions = [];
         const messageHashes = [];
         for (let i = 0; i < symbols.length; i++) {
             const market = this.market(symbols[i]);
@@ -119,6 +120,10 @@ class bitmart extends bitmart$1 {
             rawSubscriptions.push(message);
             messageHashes.push(channel + ':' + market['symbol']);
         }
+        // as an exclusion, futures "tickers" need one generic request for all symbols
+        if ((type !== 'spot') && (channel === 'ticker')) {
+            rawSubscriptions = [channelType + '/' + channel];
+        }
         const request = {
             'args': rawSubscriptions,
         };
@@ -321,13 +326,8 @@ class bitmart extends bitmart$1 {
          */
         await this.loadMarkets();
         symbol = this.symbol(symbol);
-        const market = this.market(symbol);
-        let type = 'spot';
-        [type, params] = this.handleMarketTypeAndParams('watchTicker', market, params);
-        if (type === 'swap') {
-            throw new errors.NotSupported(this.id + ' watchTicker() does not support ' + type + ' markets. Use watchTickers() instead');
-        }
-        return await this.subscribe('ticker', symbol, type, params);
+        const tickers = await this.watchTickers([symbol], params);
+        return tickers[symbol];
     }
     async watchTickers(symbols = undefined, params = {}) {
         /**
@@ -341,40 +341,12 @@ class bitmart extends bitmart$1 {
          */
         await this.loadMarkets();
         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);
-        let messageHash = 'tickers::' + type;
-        if (symbols !== undefined) {
-            messageHash += '::' + symbols.join(',');
-        }
-        let request = undefined;
-        let tickers = undefined;
-        const isSpot = (type === 'spot');
-        if (isSpot) {
-            if (symbols === undefined) {
-                throw new errors.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);
-        }
+        let marketType = undefined;
+        [marketType, params] = this.handleMarketTypeAndParams('watchTickers', market, params);
+        const ticker = await this.subscribeMultiple('ticker', marketType, symbols, params);
         if (this.newUpdates) {
+            const tickers = {};
+            tickers[ticker['symbol']] = ticker;
             return tickers;
         }
         return this.filterByArray(this.tickers, 'symbol', symbols);
@@ -850,21 +822,34 @@ class bitmart extends bitmart$1 {
         if (data === undefined) {
             return;
         }
-        let stored = undefined;
         let symbol = undefined;
-        for (let i = 0; i < data.length; i++) {
-            const trade = this.parseWsTrade(data[i]);
-            symbol = trade['symbol'];
-            const tradesLimit = this.safeInteger(this.options, 'tradesLimit', 1000);
-            stored = this.safeValue(this.trades, symbol);
-            if (stored === undefined) {
-                stored = new Cache.ArrayCache(tradesLimit);
-                this.trades[symbol] = stored;
+        const length = data.length;
+        const isSwap = ('group' in message);
+        if (isSwap) {
+            // in swap, chronologically decreasing: 1709536849322, 1709536848954,
+            const maxLen = Math.max(length - 1, 0);
+            for (let i = maxLen; i >= 0; i--) {
+                symbol = this.handleTradeLoop(data[i]);
+            }
+        }
+        else {
+            // in spot, chronologically increasing: 1709536771200, 1709536771226,
+            for (let i = 0; i < length; i++) {
+                symbol = this.handleTradeLoop(data[i]);
             }
-            stored.append(trade);
         }
-        const messageHash = 'trade:' + symbol;
-        client.resolve(stored, messageHash);
+        client.resolve(this.trades[symbol], 'trade:' + symbol);
+    }
+    handleTradeLoop(entry) {
+        const trade = this.parseWsTrade(entry);
+        const symbol = trade['symbol'];
+        const tradesLimit = this.safeInteger(this.options, 'tradesLimit', 1000);
+        if (this.safeValue(this.trades, symbol) === undefined) {
+            this.trades[symbol] = new Cache.ArrayCache(tradesLimit);
+        }
+        const stored = this.trades[symbol];
+        stored.append(trade);
+        return symbol;
     }
     parseWsTrade(trade, market = undefined) {
         // spot
@@ -943,45 +928,22 @@ class bitmart extends bitmart$1 {
         //
         const table = this.safeString(message, 'table');
         const isSpot = (table !== undefined);
-        const data = this.safeValue(message, 'data');
-        if (data === undefined) {
-            return;
-        }
+        let rawTickers = [];
         if (isSpot) {
-            for (let i = 0; i < data.length; i++) {
-                const ticker = this.parseTicker(data[i]);
-                const symbol = ticker['symbol'];
-                const marketId = this.safeString(ticker['info'], 'symbol');
-                const messageHash = table + ':' + marketId;
-                this.tickers[symbol] = ticker;
-                client.resolve(ticker, messageHash);
-                this.resolveMessageHashesForSymbol(client, symbol, ticker, 'tickers::');
-            }
+            rawTickers = this.safeList(message, 'data', []);
         }
         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::swap');
-            this.resolveMessageHashesForSymbol(client, symbol, ticker, 'tickers::');
+            rawTickers = [this.safeValue(message, 'data', {})];
         }
-    }
-    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);
-            }
+        if (!rawTickers.length) {
+            return;
+        }
+        for (let i = 0; i < rawTickers.length; i++) {
+            const ticker = isSpot ? this.parseTicker(rawTickers[i]) : this.parseWsSwapTicker(rawTickers[i]);
+            const symbol = ticker['symbol'];
+            this.tickers[symbol] = ticker;
+            const messageHash = 'ticker:' + symbol;
+            client.resolve(ticker, messageHash);
         }
     }
     parseWsSwapTicker(ticker, market = undefined) {