ccxt 4.3.20 → 4.3.22

package/js/src/phemex.js

@@ -1707,6 +1707,26 @@ export default class phemex extends Exchange {
         //         "execId": "8718cae",
         //         "execStatus": 6
         //     }
+        // spot with fees paid using PT token
+        //     "createdAt": "1714990724076",
+        //     "symbol": "BTCUSDT",
+        //     "currency": "USDT",
+        //     "action": "1",
+        //     "tradeType": "1",
+        //     "execQtyRq": "0.003",
+        //     "execPriceRp": "64935",
+        //     "side": "2",
+        //     "orderQtyRq": "0.003",
+        //     "priceRp": "51600",
+        //     "execValueRv": "194.805",
+        //     "feeRateRr": "0.000495",
+        //     "execFeeRv": "0",
+        //     "ordType": "3",
+        //     "execId": "XXXXXX",
+        //     "execStatus": "7",
+        //     "posSide": "1",
+        //     "ptFeeRv": "0.110012249248",
+        //     "ptPriceRp": "0.876524893"
         //
         let priceString;
         let amountString;
@@ -1763,10 +1783,19 @@ export default class phemex extends Exchange {
                 priceString = this.safeString(trade, 'execPriceRp');
                 amountString = this.safeString(trade, 'execQtyRq');
                 costString = this.safeString(trade, 'execValueRv');
-                feeCostString = this.safeString(trade, 'execFeeRv');
+                feeCostString = this.omitZero(this.safeString(trade, 'execFeeRv'));
                 feeRateString = this.safeString(trade, 'feeRateRr');
-                const currencyId = this.safeString(trade, 'currency');
-                feeCurrencyCode = this.safeCurrencyCode(currencyId);
+                if (feeCostString !== undefined) {
+                    const currencyId = this.safeString(trade, 'currency');
+                    feeCurrencyCode = this.safeCurrencyCode(currencyId);
+                }
+                else {
+                    const ptFeeRv = this.omitZero(this.safeString(trade, 'ptFeeRv'));
+                    if (ptFeeRv !== undefined) {
+                        feeCostString = ptFeeRv;
+                        feeCurrencyCode = 'PT';
+                    }
+                }
             }
             else {
                 side = this.safeStringLower(trade, 'side');
@@ -1779,7 +1808,7 @@ export default class phemex extends Exchange {
                 amountString = this.fromEv(this.safeString(trade, 'execBaseQtyEv'), market);
                 amountString = this.safeString(trade, 'execQty', amountString);
                 costString = this.fromEr(this.safeString2(trade, 'execQuoteQtyEv', 'execValueEv'), market);
-                feeCostString = this.fromEr(this.safeString(trade, 'execFeeEv'), market);
+                feeCostString = this.fromEr(this.omitZero(this.safeString(trade, 'execFeeEv')), market);
                 if (feeCostString !== undefined) {
                     feeRateString = this.fromEr(this.safeString(trade, 'feeRateEr'), market);
                     if (market['spot']) {
@@ -1793,6 +1822,12 @@ export default class phemex extends Exchange {
                         }
                     }
                 }
+                else {
+                    feeCostString = this.safeString(trade, 'ptFeeRv');
+                    if (feeCostString !== undefined) {
+                        feeCurrencyCode = 'PT';
+                    }
+                }
             }
             fee = {
                 'cost': feeCostString,

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

@@ -1,5 +1,5 @@
 import kucoinfuturesRest from '../kucoinfutures.js';
-import type { Int, Str, OrderBook, Order, Trade, Ticker, Balances, Position, Strings, Tickers } from '../base/types.js';
+import type { Int, Str, OrderBook, Order, Trade, Ticker, Balances, Position, Strings, Tickers, OHLCV } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class kucoinfutures extends kucoinfuturesRest {
     describe(): any;
@@ -23,6 +23,8 @@ export default class kucoinfutures extends kucoinfuturesRest {
     watchTrades(symbol: string, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     watchTradesForSymbols(symbols: string[], since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     handleTrade(client: Client, message: any): any;
+    watchOHLCV(symbol: string, timeframe?: string, since?: Int, limit?: Int, params?: {}): Promise<OHLCV[]>;
+    handleOHLCV(client: Client, message: any): void;
     watchOrderBook(symbol: string, limit?: Int, params?: {}): Promise<OrderBook>;
     watchOrderBookForSymbols(symbols: string[], limit?: Int, params?: {}): Promise<OrderBook>;
     handleDelta(orderbook: any, delta: any): void;

package/js/src/pro/kucoinfutures.js

@@ -7,7 +7,7 @@
 //  ---------------------------------------------------------------------------
 import kucoinfuturesRest from '../kucoinfutures.js';
 import { ExchangeError, ArgumentsRequired } from '../base/errors.js';
-import { ArrayCache, ArrayCacheBySymbolById } from '../base/ws/Cache.js';
+import { ArrayCache, ArrayCacheBySymbolById, ArrayCacheByTimestamp } from '../base/ws/Cache.js';
 //  ---------------------------------------------------------------------------
 export default class kucoinfutures extends kucoinfuturesRest {
     describe() {
@@ -18,6 +18,7 @@ export default class kucoinfutures extends kucoinfuturesRest {
                 'watchTickers': true,
                 'watchBidsAsks': true,
                 'watchTrades': true,
+                'watchOHLCV': true,
                 'watchOrderBook': true,
                 'watchOrders': true,
                 'watchBalance': true,
@@ -28,6 +29,21 @@ export default class kucoinfutures extends kucoinfuturesRest {
                 'watchOrderBookForSymbols': true,
             },
             'options': {
+                'timeframes': {
+                    '1m': '1min',
+                    '3m': '1min',
+                    '5m': '5min',
+                    '15m': '15min',
+                    '30m': '30min',
+                    '1h': '1hour',
+                    '2h': '2hour',
+                    '4h': '4hour',
+                    '8h': '8hour',
+                    '12h': '12hour',
+                    '1d': '1day',
+                    '1w': '1week',
+                    '1M': '1month',
+                },
                 'accountsByType': {
                     'swap': 'future',
                     'cross': 'margin',
@@ -570,6 +586,81 @@ export default class kucoinfutures extends kucoinfuturesRest {
         client.resolve(trades, messageHash);
         return message;
     }
+    async watchOHLCV(symbol, timeframe = '1m', since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name kucoinfutures#watchOHLCV
+         * @see https://www.kucoin.com/docs/websocket/futures-trading/public-channels/klines
+         * @description watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+         * @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();
+        symbol = this.symbol(symbol);
+        const url = await this.negotiate(false);
+        const marketId = this.marketId(symbol);
+        const timeframes = this.safeDict(this.options, 'timeframes');
+        const timeframeId = this.safeString(timeframes, timeframe, timeframe);
+        const topic = '/contractMarket/limitCandle:' + marketId + '_' + timeframeId;
+        const messageHash = 'ohlcv::' + symbol + '_' + timeframe;
+        const ohlcv = await this.subscribe(url, messageHash, topic, undefined, params);
+        if (this.newUpdates) {
+            limit = ohlcv.getLimit(symbol, limit);
+        }
+        return this.filterBySinceLimit(ohlcv, since, limit, 0, true);
+    }
+    handleOHLCV(client, message) {
+        //
+        //    {
+        //        "topic":"/contractMarket/limitCandle:LTCUSDTM_1min",
+        //        "type":"message",
+        //        "data":{
+        //            "symbol":"LTCUSDTM",
+        //            "candles":[
+        //                "1715470980",
+        //                "81.38",
+        //                "81.38",
+        //                "81.38",
+        //                "81.38",
+        //                "61.0",
+        //                "61"
+        //            ],
+        //            "time":1715470994801
+        //        },
+        //        "subject":"candle.stick"
+        //    }
+        //
+        const topic = this.safeString(message, 'topic');
+        const parts = topic.split('_');
+        const timeframeId = this.safeString(parts, 1);
+        const data = this.safeDict(message, 'data');
+        const timeframes = this.safeDict(this.options, 'timeframes');
+        const timeframe = this.findTimeframe(timeframeId, timeframes);
+        const marketId = this.safeString(data, 'symbol');
+        const symbol = this.safeSymbol(marketId);
+        const messageHash = 'ohlcv::' + symbol + '_' + timeframe;
+        const ohlcv = this.safeList(data, 'candles');
+        const parsed = [
+            this.safeInteger(ohlcv, 0),
+            this.safeNumber(ohlcv, 1),
+            this.safeNumber(ohlcv, 2),
+            this.safeNumber(ohlcv, 3),
+            this.safeNumber(ohlcv, 4),
+            this.safeNumber(ohlcv, 6), // Note value 5 is incorrect and will be fixed in subsequent versions of kucoin
+        ];
+        this.ohlcvs[symbol] = this.safeDict(this.ohlcvs, symbol, {});
+        if (!(timeframe in this.ohlcvs[symbol])) {
+            const limit = this.safeInteger(this.options, 'OHLCVLimit', 1000);
+            this.ohlcvs[symbol][timeframe] = new ArrayCacheByTimestamp(limit);
+        }
+        const stored = this.ohlcvs[symbol][timeframe];
+        stored.append(parsed);
+        client.resolve(stored, messageHash);
+    }
     async watchOrderBook(symbol, limit = undefined, params = {}) {
         /**
          * @method
@@ -986,6 +1077,7 @@ export default class kucoinfutures extends kucoinfuturesRest {
         const methods = {
             'level2': this.handleOrderBook,
             'ticker': this.handleTicker,
+            'candle.stick': this.handleOHLCV,
             'tickerV2': this.handleBidAsk,
             'availableBalance.change': this.handleBalance,
             'match': this.handleTrade,

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

@@ -20,11 +20,12 @@ export default class woo extends wooRest {
     checkRequiredUid(error?: boolean): boolean;
     authenticate(params?: {}): Promise<any>;
     watchPrivate(messageHash: any, message: any, params?: {}): Promise<any>;
+    watchPrivateMultiple(messageHashes: any, message: any, params?: {}): Promise<any>;
     watchOrders(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Order[]>;
     watchMyTrades(symbol?: Str, since?: Int, limit?: Int, params?: {}): Promise<Trade[]>;
     parseWsOrder(order: any, market?: any): Order;
     handleOrderUpdate(client: Client, message: any): void;
-    handleOrder(client: Client, message: any): void;
+    handleOrder(client: Client, message: any, topic: any): void;
     handleMyTrade(client: Client, message: any): void;
     watchPositions(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<Position[]>;
     setPositionsCache(client: Client, type: any, symbols?: Strings): void;

package/js/src/pro/woo.js

@@ -550,6 +550,16 @@ export default class woo extends wooRest {
         const request = this.extend(subscribe, message);
         return await this.watch(url, messageHash, request, messageHash, subscribe);
     }
+    async watchPrivateMultiple(messageHashes, message, params = {}) {
+        await this.authenticate(params);
+        const url = this.urls['api']['ws']['private'] + '/' + this.uid;
+        const requestId = this.requestId(url);
+        const subscribe = {
+            'id': requestId,
+        };
+        const request = this.extend(subscribe, message);
+        return await this.watchMultiple(url, messageHashes, request, messageHashes, subscribe);
+    }
     async watchOrders(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         /**
          * @method
@@ -561,10 +571,13 @@ export default class woo extends wooRest {
          * @param {int} [since] the earliest time in ms to fetch orders for
          * @param {int} [limit] the maximum number of order structures to retrieve
          * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {bool} [params.trigger] true if trigger order
          * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
          */
         await this.loadMarkets();
-        const topic = 'executionreport';
+        const trigger = this.safeBool2(params, 'stop', 'trigger', false);
+        const topic = (trigger) ? 'algoexecutionreportv2' : 'executionreport';
+        params = this.omit(params, ['stop', 'trigger']);
         let messageHash = topic;
         if (symbol !== undefined) {
             const market = this.market(symbol);
@@ -587,15 +600,19 @@ export default class woo extends wooRest {
          * @method
          * @name woo#watchOrders
          * @see https://docs.woo.org/#executionreport
+         * @see https://docs.woo.org/#algoexecutionreportv2
          * @description watches information on multiple trades made by the user
          * @param {string} symbol unified market symbol of the market orders were made in
          * @param {int} [since] the earliest time in ms to fetch orders for
          * @param {int} [limit] the maximum number of order structures to retrieve
          * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @param {bool} [params.trigger] true if trigger order
          * @returns {object[]} a list of [order structures]{@link https://docs.ccxt.com/#/?id=order-structure}
          */
         await this.loadMarkets();
-        const topic = 'executionreport';
+        const trigger = this.safeBool2(params, 'stop', 'trigger', false);
+        const topic = (trigger) ? 'algoexecutionreportv2' : 'executionreport';
+        params = this.omit(params, ['stop', 'trigger']);
         let messageHash = 'myTrades';
         if (symbol !== undefined) {
             const market = this.market(symbol);
@@ -721,15 +738,29 @@ export default class woo extends wooRest {
         //         }
         //     }
         //
-        const order = this.safeDict(message, 'data');
-        const tradeId = this.safeString(order, 'tradeId');
-        if ((tradeId !== undefined) && (tradeId !== '0')) {
-            this.handleMyTrade(client, order);
+        const topic = this.safeString(message, 'topic');
+        const data = this.safeValue(message, 'data');
+        if (Array.isArray(data)) {
+            // algoexecutionreportv2
+            for (let i = 0; i < data.length; i++) {
+                const order = data[i];
+                const tradeId = this.omitZero(this.safeString(data, 'tradeId'));
+                if (tradeId !== undefined) {
+                    this.handleMyTrade(client, order);
+                }
+                this.handleOrder(client, order, topic);
+            }
+        }
+        else {
+            // executionreport
+            const tradeId = this.omitZero(this.safeString(data, 'tradeId'));
+            if (tradeId !== undefined) {
+                this.handleMyTrade(client, data);
+            }
+            this.handleOrder(client, data, topic);
         }
-        this.handleOrder(client, order);
     }
-    handleOrder(client, message) {
-        const topic = 'executionreport';
+    handleOrder(client, message, topic) {
         const parsed = this.parseWsOrder(message);
         const symbol = this.safeString(parsed, 'symbol');
         const orderId = this.safeString(parsed, 'id');
@@ -814,12 +845,17 @@ export default class woo extends wooRest {
          * @returns {object[]} a list of [position structure]{@link https://docs.ccxt.com/en/latest/manual.html#position-structure}
          */
         await this.loadMarkets();
-        let messageHash = '';
+        const messageHashes = [];
         symbols = this.marketSymbols(symbols);
         if (!this.isEmpty(symbols)) {
-            messageHash = '::' + symbols.join(',');
+            for (let i = 0; i < symbols.length; i++) {
+                const symbol = symbols[i];
+                messageHashes.push('positions::' + symbol);
+            }
+        }
+        else {
+            messageHashes.push('positions');
         }
-        messageHash = 'positions' + messageHash;
         const url = this.urls['api']['ws']['private'] + '/' + this.uid;
         const client = this.client(url);
         this.setPositionsCache(client, symbols);
@@ -833,7 +869,7 @@ export default class woo extends wooRest {
             'event': 'subscribe',
             'topic': 'position',
         };
-        const newPositions = await this.watchPrivate(messageHash, request, params);
+        const newPositions = await this.watchPrivateMultiple(messageHashes, request, params);
         if (this.newUpdates) {
             return newPositions;
         }
@@ -909,17 +945,8 @@ export default class woo extends wooRest {
             const position = this.parsePosition(rawPosition, market);
             newPositions.push(position);
             cache.append(position);
-        }
-        const messageHashes = this.findMessageHashes(client, 'positions::');
-        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 positions = this.filterByArray(newPositions, 'symbol', symbols, false);
-            if (!this.isEmpty(positions)) {
-                client.resolve(positions, messageHash);
-            }
+            const messageHash = 'positions::' + market['symbol'];
+            client.resolve(position, messageHash);
         }
         client.resolve(newPositions, 'positions');
     }
@@ -1040,6 +1067,7 @@ export default class woo extends wooRest {
             'kline': this.handleOHLCV,
             'auth': this.handleAuth,
             'executionreport': this.handleOrderUpdate,
+            'algoexecutionreportv2': this.handleOrderUpdate,
             'trade': this.handleTrade,
             'balance': this.handleBalance,
             'position': this.handlePositions,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccxt",
-  "version": "4.3.20",
+  "version": "4.3.22",
   "description": "A JavaScript / TypeScript / Python / C# / PHP cryptocurrency trading library with support for 100+ exchanges",
   "unpkg": "dist/ccxt.browser.js",
   "type": "module",