ccxt 4.2.58 → 4.2.59

package/js/src/coinbase.js

@@ -3068,10 +3068,12 @@ export default class coinbase extends Exchange {
          * @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 = {
@@ -3081,20 +3083,20 @@ export default class coinbase extends Exchange {
         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.stringSub(now, candles300.toString());
+            sinceString = Precise.stringSub(now, requestedDuration.toString());
         }
         request['start'] = sinceString;
         let endString = this.numberToString(until);
         if (until === undefined) {
             // 300 candles max
-            endString = Precise.stringAdd(sinceString, candles300.toString());
+            endString = Precise.stringAdd(sinceString, requestedDuration.toString());
         }
         request['end'] = endString;
         const response = await this.v3PrivateGetBrokerageProductsProductIdCandles(this.extend(request, params));
@@ -3154,8 +3156,19 @@ export default class coinbase extends Exchange {
         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 ArgumentsRequired(this.id + ' fetchTrades() requires a `until` parameter when you use `since` argument');
         }
         const response = await this.v3PrivateGetBrokerageProductsProductIdTicker(this.extend(request, params));
         //
@@ -3289,7 +3302,7 @@ export default class coinbase extends Exchange {
         //         }
         //     }
         //
-        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');
@@ -3742,7 +3755,7 @@ export default class coinbase extends Exchange {
             }
             else {
                 this.checkRequiredCredentials();
-                const nonce = this.nonce().toString();
+                const timestampString = this.seconds().toString();
                 let payload = '';
                 if (method !== 'GET') {
                     if (Object.keys(query).length) {
@@ -3750,17 +3763,14 @@ export default class coinbase extends Exchange {
                         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);
                 headers = {
                     'CB-ACCESS-KEY': this.apiKey,
                     'CB-ACCESS-SIGN': signature,
-                    'CB-ACCESS-TIMESTAMP': nonce,
+                    'CB-ACCESS-TIMESTAMP': timestampString,
                     'Content-Type': 'application/json',
                 };
             }

package/js/src/lbank.js

@@ -2694,7 +2694,7 @@ export default class lbank extends Exchange {
             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/js/src/mexc.js

@@ -5500,7 +5500,7 @@ export default class mexc extends Exchange {
                     '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/js/src/okx.js

@@ -1560,7 +1560,7 @@ export default class okx extends Exchange {
         // 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;
         }

package/js/src/phemex.js

@@ -2422,7 +2422,7 @@ export default class phemex extends Exchange {
     }
     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/js/src/pro/binance.js

@@ -2468,7 +2468,7 @@ export default class binance extends binanceRest {
         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/js/src/pro/bitfinex2.js

@@ -56,7 +56,7 @@ export default class bitfinex2 extends bitfinex2Rest {
             '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/js/src/pro/bitget.js

@@ -539,7 +539,7 @@ export default class bitget extends bitgetRest {
             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/js/src/pro/bitmart.d.ts

@@ -4,7 +4,7 @@ import Client from '../base/ws/Client.js';
 export default class bitmart extends bitmartRest {
     describe(): any;
     subscribe(channel: any, symbol: any, type: any, params?: {}): Promise<any>;
-    subscribeMultiple(channel: string, type: string, symbols: string[], params?: {}): Promise<any>;
+    subscribeMultiple(channel: string, type: string, symbols?: Strings, params?: {}): Promise<any>;
     watchBalance(params?: {}): Promise<Balances>;
     setBalanceCache(client: Client, type: any, subscribeHash: any): void;
     loadBalanceSnapshot(client: any, messageHash: any, type: any): Promise<void>;
@@ -23,9 +23,9 @@ export default class bitmart extends bitmartRest {
     handlePositions(client: Client, message: any): void;
     parseWsPosition(position: any, market?: Market): Position;
     handleTrade(client: Client, message: any): void;
+    handleTradeLoop(entry: any): string;
     parseWsTrade(trade: any, market?: Market): Trade;
     handleTicker(client: Client, message: any): void;
-    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

@@ -110,11 +110,12 @@ export default class bitmart extends bitmartRest {
         }
         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]);
@@ -122,6 +123,10 @@ export default class bitmart extends bitmartRest {
             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,
         };
@@ -324,13 +329,8 @@ export default class bitmart extends bitmartRest {
          */
         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 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 = {}) {
         /**
@@ -344,40 +344,12 @@ export default class bitmart extends bitmartRest {
          */
         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 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);
@@ -853,21 +825,34 @@ export default class bitmart extends bitmartRest {
         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 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 ArrayCache(tradesLimit);
+        }
+        const stored = this.trades[symbol];
+        stored.append(trade);
+        return symbol;
     }
     parseWsTrade(trade, market = undefined) {
         // spot
@@ -946,45 +931,22 @@ export default class bitmart extends bitmartRest {
         //
         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) {

package/js/src/pro/bitvavo.js

@@ -1087,7 +1087,7 @@ export default class bitvavo extends bitvavoRest {
         return messageHash;
     }
     checkMessageHashDoesNotExist(messageHash) {
-        const supressMultipleWsRequestsError = this.safeValue(this.options, 'supressMultipleWsRequestsError', false);
+        const supressMultipleWsRequestsError = this.safeBool(this.options, 'supressMultipleWsRequestsError', false);
         if (!supressMultipleWsRequestsError) {
             const client = this.safeValue(this.clients, this.urls['api']['ws']);
             if (client !== undefined) {

package/js/src/pro/bybit.js

@@ -942,7 +942,7 @@ export default class bybit extends bybitRest {
         this.setPositionsCache(client, symbols);
         const cache = this.positions;
         const fetchPositionsSnapshot = this.handleOption('watchPositions', 'fetchPositionsSnapshot', true);
-        const awaitPositionsSnapshot = this.safeValue('watchPositions', 'awaitPositionsSnapshot', true);
+        const awaitPositionsSnapshot = this.safeBool('watchPositions', 'awaitPositionsSnapshot', true);
         if (fetchPositionsSnapshot && awaitPositionsSnapshot && cache === undefined) {
             const snapshot = await client.future('fetchPositionsSnapshot');
             return this.filterBySymbolsSinceLimit(snapshot, symbols, since, limit, true);

package/js/src/pro/coinex.js

@@ -549,7 +549,7 @@ export default class coinex extends coinexRest {
         }
         const url = this.urls['api']['ws'][type];
         const messageHash = 'ohlcv';
-        const watchOHLCVWarning = this.safeValue(this.options, 'watchOHLCVWarning', true);
+        const watchOHLCVWarning = this.safeBool(this.options, 'watchOHLCVWarning', true);
         const client = this.safeValue(this.clients, url, {});
         const clientSub = this.safeValue(client, 'subscriptions', {});
         const existingSubscription = this.safeValue(clientSub, messageHash);

package/js/src/pro/cryptocom.js

@@ -556,7 +556,7 @@ export default class cryptocom extends cryptocomRest {
         const client = this.client(url);
         this.setPositionsCache(client, symbols);
         const fetchPositionsSnapshot = this.handleOption('watchPositions', 'fetchPositionsSnapshot', true);
-        const awaitPositionsSnapshot = this.safeValue('watchPositions', 'awaitPositionsSnapshot', true);
+        const awaitPositionsSnapshot = this.safeBool('watchPositions', 'awaitPositionsSnapshot', true);
         if (fetchPositionsSnapshot && awaitPositionsSnapshot && this.positions === undefined) {
             const snapshot = await client.future('fetchPositionsSnapshot');
             return this.filterBySymbolsSinceLimit(snapshot, symbols, since, limit, true);

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

@@ -9,10 +9,12 @@ export default class deribit extends deribitRest {
     watchTicker(symbol: string, params?: {}): Promise<Ticker>;
     handleTicker(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;
     watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleMyTrades(client: Client, message: any): void;
     watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
+    watchOrderBookForSymbols(symbols: string[], limit?: Int, params?: {}): Promise<OrderBook>;
     handleOrderBook(client: Client, message: any): void;
     cleanOrderBook(data: any): any;
     handleDelta(bookside: any, delta: any): void;
@@ -20,7 +22,10 @@ export default class deribit extends deribitRest {
     watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     handleOrders(client: Client, message: any): void;
     watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
+    watchOHLCVForSymbols(symbolsAndTimeframes: string[][], since?: Int, limit?: Int, params?: {}): Promise<import("../base/types.js").Dictionary<import("../base/types.js").Dictionary<OHLCV[]>>>;
     handleOHLCV(client: Client, message: any): void;
+    parseWsOHLCV(ohlcv: any, market?: any): OHLCV;
+    watchMultipleWrapper(channelName: string, channelDescriptor: string, symbolsArray?: any, params?: {}): Promise<any>;
     handleMessage(client: Client, message: any): void;
     handleAuthenticationMessage(client: Client, message: any): any;
     authenticate(params?: {}): Promise<any>;