ccxt 4.3.69 → 4.3.71

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

@@ -1,5 +1,5 @@
 import coinbaseinternationalRest from '../coinbaseinternational.js';
-import { Ticker, Int, Trade, OrderBook, Market, Dict, Strings, FundingRate, FundingRates } from '../base/types.js';
+import { Ticker, Int, Trade, OrderBook, Market, Dict, Strings, FundingRate, FundingRates, Tickers, OHLCV } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class coinbaseinternational extends coinbaseinternationalRest {
     describe(): any;
@@ -8,10 +8,14 @@ export default class coinbaseinternational extends coinbaseinternationalRest {
     watchFundingRate(symbol: string, params?: {}): Promise<FundingRate>;
     watchFundingRates(symbols: string[], params?: {}): Promise<FundingRates>;
     watchTicker(symbol: string, params?: {}): Promise<Ticker>;
+    getActiveSymbols(): any[];
+    watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
     handleInstrument(client: Client, message: any): void;
     parseWsInstrument(ticker: Dict, market?: any): Ticker;
     handleTicker(client: Client, message: any): void;
     parseWsTicker(ticker: object, market?: Market): Ticker;
+    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
+    handleOHLCV(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[]>;
     handleTrade(client: any, message: any): any;

package/js/src/pro/coinbaseinternational.js

@@ -8,7 +8,7 @@
 import coinbaseinternationalRest from '../coinbaseinternational.js';
 import { AuthenticationError, ExchangeError, NotSupported } from '../base/errors.js';
 import { sha256 } from '../static_dependencies/noble-hashes/sha256.js';
-import { ArrayCache } from '../base/ws/Cache.js';
+import { ArrayCache, ArrayCacheByTimestamp } from '../base/ws/Cache.js';
 //  ---------------------------------------------------------------------------
 export default class coinbaseinternational extends coinbaseinternationalRest {
     describe() {
@@ -22,12 +22,12 @@ export default class coinbaseinternational extends coinbaseinternationalRest {
                 'watchTicker': true,
                 'watchBalance': false,
                 'watchMyTrades': false,
-                'watchOHLCV': false,
+                'watchOHLCV': true,
                 'watchOHLCVForSymbols': false,
                 'watchOrders': false,
                 'watchOrdersForSymbols': false,
                 'watchPositions': false,
-                'watchTickers': false,
+                'watchTickers': true,
                 'createOrderWs': false,
                 'editOrderWs': false,
                 'cancelOrderWs': false,
@@ -53,6 +53,14 @@ export default class coinbaseinternational extends coinbaseinternationalRest {
                 'tradesLimit': 1000,
                 'ordersLimit': 1000,
                 'myTradesLimit': 1000,
+                'timeframes': {
+                    '1m': 'CANDLES_ONE_MINUTE',
+                    '5m': 'CANDLES_FIVE_MINUTES',
+                    '30m': 'CANDLES_THIRTY_MINUTES',
+                    '1h': 'CANDLES_ONE_HOUR',
+                    '2h': 'CANDLES_TWO_HOURS',
+                    '1d': 'CANDLES_ONE_DAY',
+                },
             },
             'exceptions': {
                 'exact': {
@@ -76,16 +84,20 @@ export default class coinbaseinternational extends coinbaseinternationalRest {
         this.checkRequiredCredentials();
         let market = undefined;
         let messageHash = name;
-        let productIds = [];
+        let productIds = undefined;
         if (symbols === undefined) {
-            symbols = this.symbols;
+            symbols = this.getActiveSymbols();
         }
         const symbolsLength = symbols.length;
+        const messageHashes = [];
         if (symbolsLength > 1) {
             const parsedSymbols = this.marketSymbols(symbols);
             const marketIds = this.marketIds(parsedSymbols);
             productIds = marketIds;
-            messageHash = messageHash + '::' + parsedSymbols.join(',');
+            for (let i = 0; i < parsedSymbols.length; i++) {
+                messageHashes.push(name + '::' + parsedSymbols[i]);
+            }
+            // messageHash = messageHash + '::' + parsedSymbols.join (',');
         }
         else if (symbolsLength === 1) {
             market = this.market(symbols[0]);
@@ -101,13 +113,19 @@ export default class coinbaseinternational extends coinbaseinternationalRest {
         const signature = this.hmac(this.encode(auth), this.base64ToBinary(this.secret), sha256, 'base64');
         const subscribe = {
             'type': 'SUBSCRIBE',
-            'product_ids': productIds,
+            // 'product_ids': productIds,
             'channels': [name],
             'time': timestamp,
             'key': this.apiKey,
             'passphrase': this.password,
             'signature': signature,
         };
+        if (productIds !== undefined) {
+            subscribe['product_ids'] = productIds;
+        }
+        if (symbolsLength > 1) {
+            return await this.watchMultiple(url, messageHashes, this.extend(subscribe, params), messageHashes);
+        }
         return await this.watch(url, messageHash, this.extend(subscribe, params), messageHash);
     }
     async subscribeMultiple(name, symbols = undefined, params = {}) {
@@ -196,6 +214,7 @@ export default class coinbaseinternational extends coinbaseinternationalRest {
          * @see https://docs.cloud.coinbase.com/intx/docs/websocket-channels#instruments-channel
          * @param {string} [symbol] unified symbol of the market to fetch the ticker for
          * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {string} [params.channel] the channel to watch, 'LEVEL1' or 'INSTRUMENTS', default is 'LEVEL1'
          * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
          */
         await this.loadMarkets();
@@ -203,6 +222,40 @@ export default class coinbaseinternational extends coinbaseinternationalRest {
         [channel, params] = this.handleOptionAndParams(params, 'watchTicker', 'channel', 'LEVEL1');
         return await this.subscribe(channel, [symbol], params);
     }
+    getActiveSymbols() {
+        const symbols = this.symbols;
+        const output = [];
+        for (let i = 0; i < symbols.length; i++) {
+            const symbol = symbols[i];
+            const market = this.markets[symbol];
+            if (market['active']) {
+                output.push(symbol);
+            }
+        }
+        return output;
+    }
+    async watchTickers(symbols = undefined, params = {}) {
+        /**
+         * @method
+         * @name coinbaseinternational#watchTickers
+         * @description watches a price ticker, a statistical calculation with the information calculated over the past 24 hours for a specific market
+         * @see https://docs.cloud.coinbase.com/intx/docs/websocket-channels#instruments-channel
+         * @param {string[]} [symbols] unified symbol of the market to fetch the ticker for
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {string} [params.channel] the channel to watch, 'LEVEL1' or 'INSTRUMENTS', default is 'INSTLEVEL1UMENTS'
+         * @returns {object} a [ticker structure]{@link https://docs.ccxt.com/#/?id=ticker-structure}
+         */
+        await this.loadMarkets();
+        let channel = undefined;
+        [channel, params] = this.handleOptionAndParams(params, 'watchTickers', 'channel', 'LEVEL1');
+        const ticker = await this.subscribe(channel, symbols, params);
+        if (this.newUpdates) {
+            const result = {};
+            result[ticker['symbol']] = ticker;
+            return result;
+        }
+        return this.filterByArray(this.tickers, 'symbol', symbols);
+    }
     handleInstrument(client, message) {
         //
         //    {
@@ -260,6 +313,33 @@ export default class coinbaseinternational extends coinbaseinternationalRest {
         //        "channel":"INSTRUMENTS",
         //        "type":"SNAPSHOT"
         //    }
+        // instruments
+        //   {
+        //       sequence: 0,
+        //       instrument_type: 'PERP',
+        //       instrument_mode: 'standard',
+        //       base_asset_name: 'BTC',
+        //       quote_asset_name: 'USDC',
+        //       base_increment: '0.0001',
+        //       quote_increment: '0.1',
+        //       avg_daily_quantity: '502.8845',
+        //       avg_daily_volume: '3.1495242961566668E7',
+        //       total30_day_quantity: '15086.535',
+        //       total30_day_volume: '9.44857288847E8',
+        //       total24_hour_quantity: '5.0',
+        //       total24_hour_volume: '337016.5',
+        //       base_imf: '0.1',
+        //       min_quantity: '0.0001',
+        //       position_size_limit: '800',
+        //       funding_interval: '3600000000000',
+        //       trading_state: 'trading',
+        //       last_updated_time: '2024-07-30T15:00:00Z',
+        //       default_initial_margin: '0.2',
+        //       base_asset_multiplier: '1.0',
+        //       channel: 'INSTRUMENTS',
+        //       type: 'SNAPSHOT',
+        //       time: '2024-07-30T15:26:56.766Z',
+        //   }
         //
         const marketId = this.safeString(ticker, 'product_id');
         const datetime = this.safeString(ticker, 'time');
@@ -282,8 +362,8 @@ export default class coinbaseinternational extends coinbaseinternationalRest {
             'change': undefined,
             'percentage': undefined,
             'average': undefined,
-            'baseVolume': this.safeString(ticker, 'total_24_hour_quantity'),
-            'quoteVolume': this.safeString(ticker, 'total_24_hour_volume'),
+            'baseVolume': this.safeString2(ticker, 'total_24_hour_quantity', 'total24_hour_quantity'),
+            'quoteVolume': this.safeString2(ticker, 'total_24_hour_volume', 'total24_hour_volume'),
         });
     }
     handleTicker(client, message) {
@@ -355,6 +435,68 @@ export default class coinbaseinternational extends coinbaseinternationalRest {
             'previousClose': undefined,
         });
     }
+    async watchOHLCV(symbol, timeframe = '1m', since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name coinbaseinternational#watchOHLCV
+         * @description watches historical candlestick data containing the open, high, low, close price, and the volume of a market
+         * @see https://docs.cdp.coinbase.com/intx/docs/websocket-channels#candles-channel
+         * @param {string} symbol unified symbol of the market to fetch OHLCV data for
+         * @param {string} timeframe the length of time each candle represents
+         * @param {int} [since] timestamp in ms of the earliest candle to fetch
+         * @param {int} [limit] the maximum amount of candles to fetch
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {int[][]} A list of candles ordered as timestamp, open, high, low, close, volume
+         */
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        symbol = market['symbol'];
+        const options = this.safeDict(this.options, 'timeframes', {});
+        const interval = this.safeString(options, timeframe, timeframe);
+        const ohlcv = await this.subscribe(interval, [symbol], params);
+        if (this.newUpdates) {
+            limit = ohlcv.getLimit(symbol, limit);
+        }
+        return this.filterBySinceLimit(ohlcv, since, limit, 0, true);
+    }
+    handleOHLCV(client, message) {
+        //
+        // {
+        //     "sequence": 0,
+        //     "product_id": "BTC-PERP",
+        //     "channel": "CANDLES_ONE_MINUTE",
+        //     "type": "SNAPSHOT",
+        //     "candles": [
+        //       {
+        //           "time": "2023-05-10T14:58:47.000Z",
+        //           "low": "28787.8",
+        //           "high": "28788.8",
+        //           "open": "28788.8",
+        //           "close": "28787.8",
+        //           "volume": "0.466"
+        //        },
+        //     ]
+        //  }
+        //
+        const messageHash = this.safeString(message, 'channel');
+        const marketId = this.safeString(message, 'product_id');
+        const market = this.safeMarket(marketId);
+        const symbol = market['symbol'];
+        const timeframe = this.findTimeframe(messageHash);
+        this.ohlcvs[symbol] = this.safeValue(this.ohlcvs, symbol, {});
+        if (this.safeValue(this.ohlcvs[symbol], timeframe) === undefined) {
+            const limit = this.safeInteger(this.options, 'OHLCVLimit', 1000);
+            this.ohlcvs[symbol][timeframe] = new ArrayCacheByTimestamp(limit);
+        }
+        const stored = this.ohlcvs[symbol][timeframe];
+        const data = this.safeList(message, 'candles', []);
+        for (let i = 0; i < data.length; i++) {
+            const tick = data[i];
+            const parsed = this.parseOHLCV(tick, market);
+            stored.append(parsed);
+        }
+        client.resolve(stored, messageHash + '::' + symbol);
+    }
     async watchTrades(symbol, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -636,7 +778,7 @@ export default class coinbaseinternational extends coinbaseinternationalRest {
         if (this.handleErrorMessage(client, message)) {
             return;
         }
-        const channel = this.safeString(message, 'channel');
+        const channel = this.safeString(message, 'channel', '');
         const methods = {
             'SUBSCRIPTIONS': this.handleSubscriptionStatus,
             'INSTRUMENTS': this.handleInstrument,
@@ -651,6 +793,9 @@ export default class coinbaseinternational extends coinbaseinternationalRest {
             const errorMessage = this.safeString(message, 'message');
             throw new ExchangeError(errorMessage);
         }
+        if (channel.indexOf('CANDLES') > -1) {
+            this.handleOHLCV(client, message);
+        }
         const method = this.safeValue(methods, channel);
         if (method !== undefined) {
             method.call(this, client, message);

package/js/src/pro/cryptocom.js

@@ -6,7 +6,7 @@
 
 //  ---------------------------------------------------------------------------
 import cryptocomRest from '../cryptocom.js';
-import { AuthenticationError, ChecksumError, NetworkError } from '../base/errors.js';
+import { AuthenticationError, ChecksumError, ExchangeError, NetworkError } from '../base/errors.js';
 import { ArrayCache, ArrayCacheByTimestamp, ArrayCacheBySymbolById, ArrayCacheBySymbolBySide } from '../base/ws/Cache.js';
 import { sha256 } from '../static_dependencies/noble-hashes/sha256.js';
 //  ---------------------------------------------------------------------------
@@ -889,6 +889,7 @@ export default class cryptocom extends cryptocomRest {
         //        "message": "invalid channel {"channels":["trade.BTCUSD-PERP"]}"
         //    }
         //
+        const id = this.safeString(message, 'id');
         const errorCode = this.safeString(message, 'code');
         try {
             if (errorCode && errorCode !== '0') {
@@ -898,6 +899,7 @@ export default class cryptocom extends cryptocomRest {
                 if (messageString !== undefined) {
                     this.throwBroadlyMatchedException(this.exceptions['broad'], messageString, feedback);
                 }
+                throw new ExchangeError(feedback);
             }
             return false;
         }
@@ -910,7 +912,7 @@ export default class cryptocom extends cryptocomRest {
                 }
             }
             else {
-                client.reject(e);
+                client.reject(e, id);
             }
             return true;
         }

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

@@ -38,5 +38,5 @@ export default class hitbtc extends hitbtcRest {
     handleOrderRequest(client: Client, message: any): any;
     handleMessage(client: Client, message: any): void;
     handleAuthenticate(client: Client, message: any): any;
-    handleError(client: Client, message: any): any;
+    handleError(client: Client, message: any): boolean;
 }

package/js/src/pro/hitbtc.js

@@ -1215,7 +1215,9 @@ export default class hitbtc extends hitbtcRest {
         return message;
     }
     handleMessage(client, message) {
-        this.handleError(client, message);
+        if (this.handleError(client, message)) {
+            return;
+        }
         let channel = this.safeString2(message, 'ch', 'method');
         if (channel !== undefined) {
             const splitChannel = channel.split('/');
@@ -1294,13 +1296,29 @@ export default class hitbtc extends hitbtcRest {
         //
         const error = this.safeValue(message, 'error');
         if (error !== undefined) {
-            const code = this.safeValue(error, 'code');
-            const errorMessage = this.safeString(error, 'message');
-            const description = this.safeString(error, 'description');
-            const feedback = this.id + ' ' + description;
-            this.throwExactlyMatchedException(this.exceptions['exact'], code, feedback);
-            this.throwBroadlyMatchedException(this.exceptions['broad'], errorMessage, feedback);
-            throw new ExchangeError(feedback); // unknown message
+            try {
+                const code = this.safeValue(error, 'code');
+                const errorMessage = this.safeString(error, 'message');
+                const description = this.safeString(error, 'description');
+                const feedback = this.id + ' ' + description;
+                this.throwExactlyMatchedException(this.exceptions['exact'], code, feedback);
+                this.throwBroadlyMatchedException(this.exceptions['broad'], errorMessage, feedback);
+                throw new ExchangeError(feedback); // unknown message
+            }
+            catch (e) {
+                if (e instanceof AuthenticationError) {
+                    const messageHash = 'authenticated';
+                    client.reject(e, messageHash);
+                    if (messageHash in client.subscriptions) {
+                        delete client.subscriptions[messageHash];
+                    }
+                }
+                else {
+                    const id = this.safeString(message, 'id');
+                    client.reject(e, id);
+                }
+                return true;
+            }
         }
         return undefined;
     }

package/js/src/pro/okx.js

@@ -1899,6 +1899,13 @@ export default class okx extends okxRest {
             }
         }
         catch (e) {
+            // if the message contains an id, it means it is a response to a request
+            // so we only reject that promise, instead of deleting all futures, destroying the authentication future
+            const id = this.safeString(message, 'id');
+            if (id !== undefined) {
+                client.reject(e, id);
+                return false;
+            }
             client.reject(e);
             return false;
         }

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

@@ -0,0 +1,15 @@
+import paradexRest from '../paradex.js';
+import type { Int, Trade, OrderBook, Ticker, Strings, Tickers } from '../base/types.js';
+import Client from '../base/ws/Client.js';
+export default class paradex extends paradexRest {
+    describe(): any;
+    watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
+    handleTrade(client: Client, message: any): any;
+    watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
+    handleOrderBook(client: Client, message: any): void;
+    watchTicker(symbol: string, params?: {}): Promise<Ticker>;
+    watchTickers(symbols?: Strings, params?: {}): Promise<Tickers>;
+    handleTicker(client: Client, message: any): any;
+    handleErrorMessage(client: Client, message: any): boolean;
+    handleMessage(client: Client, message: any): void;
+}