ccxt 4.2.13 → 4.2.15

package/js/src/kucoinfutures.js

@@ -36,10 +36,14 @@ export default class kucoinfutures extends kucoin {
                 'closePositions': false,
                 'createDepositAddress': true,
                 'createOrder': true,
+                'createOrders': true,
                 'createReduceOnlyOrder': true,
                 'createStopLimitOrder': true,
+                'createStopLossOrder': true,
                 'createStopMarketOrder': true,
                 'createStopOrder': true,
+                'createTakeProfitOrder': true,
+                'createTriggerOrder': true,
                 'fetchAccounts': true,
                 'fetchBalance': true,
                 'fetchBorrowRateHistories': false,
@@ -54,7 +58,7 @@ export default class kucoinfutures extends kucoin {
                 'fetchDepositWithdrawFees': false,
                 'fetchFundingHistory': true,
                 'fetchFundingRate': true,
-                'fetchFundingRateHistory': false,
+                'fetchFundingRateHistory': true,
                 'fetchIndexOHLCV': false,
                 'fetchIsolatedBorrowRate': false,
                 'fetchIsolatedBorrowRates': false,
@@ -1115,6 +1119,78 @@ export default class kucoinfutures extends kucoin {
          * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
          */
         await this.loadMarkets();
+        const market = this.market(symbol);
+        const testOrder = this.safeValue(params, 'test', false);
+        params = this.omit(params, 'test');
+        const orderRequest = this.createContractOrderRequest(symbol, type, side, amount, price, params);
+        let response = undefined;
+        if (testOrder) {
+            response = await this.futuresPrivatePostOrdersTest(orderRequest);
+        }
+        else {
+            response = await this.futuresPrivatePostOrders(orderRequest);
+        }
+        //
+        //    {
+        //        "code": "200000",
+        //        "data": {
+        //            "orderId": "619717484f1d010001510cde",
+        //        },
+        //    }
+        //
+        const data = this.safeValue(response, 'data', {});
+        return this.parseOrder(data, market);
+    }
+    async createOrders(orders, params = {}) {
+        /**
+         * @method
+         * @name kucoinfutures#createOrders
+         * @description create a list of trade orders
+         * @see https://www.kucoin.com/docs/rest/futures-trading/orders/place-multiple-orders
+         * @param {Array} orders list of orders to create, each object should contain the parameters required by createOrder, namely symbol, type, side, amount, price and params
+         * @param {object} [params]  extra parameters specific to the exchange API endpoint
+         * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        await this.loadMarkets();
+        const ordersRequests = [];
+        for (let i = 0; i < orders.length; i++) {
+            const rawOrder = orders[i];
+            const symbol = this.safeString(rawOrder, 'symbol');
+            const market = this.market(symbol);
+            const type = this.safeString(rawOrder, 'type');
+            const side = this.safeString(rawOrder, 'side');
+            const amount = this.safeValue(rawOrder, 'amount');
+            const price = this.safeValue(rawOrder, 'price');
+            const orderParams = this.safeValue(rawOrder, 'params', {});
+            const orderRequest = this.createContractOrderRequest(market['id'], type, side, amount, price, orderParams);
+            ordersRequests.push(orderRequest);
+        }
+        const response = await this.futuresPrivatePostOrdersMulti(ordersRequests);
+        //
+        //     {
+        //         "code": "200000",
+        //         "data": [
+        //             {
+        //                 "orderId": "135241412609331200",
+        //                 "clientOid": "3d8fcc13-0b13-447f-ad30-4b3441e05213",
+        //                 "symbol": "LTCUSDTM",
+        //                 "code": "200000",
+        //                 "msg": "success"
+        //             },
+        //             {
+        //                 "orderId": "135241412747743234",
+        //                 "clientOid": "b878c7ee-ae3e-4d63-a20b-038acbb7306f",
+        //                 "symbol": "LTCUSDTM",
+        //                 "code": "200000",
+        //                 "msg": "success"
+        //             }
+        //         ]
+        //     }
+        //
+        const data = this.safeValue(response, 'data', []);
+        return this.parseOrders(data);
+    }
+    createContractOrderRequest(symbol, type, side, amount, price = undefined, params = {}) {
         const market = this.market(symbol);
         // required param, cannot be used twice
         const clientOrderId = this.safeString2(params, 'clientOid', 'clientOrderId', this.uuid());
@@ -1187,48 +1263,7 @@ export default class kucoinfutures extends kucoin {
             }
         }
         params = this.omit(params, ['timeInForce', 'stopPrice', 'triggerPrice', 'stopLossPrice', 'takeProfitPrice']); // Time in force only valid for limit orders, exchange error when gtc for market orders
-        let response = undefined;
-        const testOrder = this.safeValue(params, 'test', false);
-        params = this.omit(params, 'test');
-        if (testOrder) {
-            response = await this.futuresPrivatePostOrdersTest(this.extend(request, params));
-        }
-        else {
-            response = await this.futuresPrivatePostOrders(this.extend(request, params));
-        }
-        //
-        //    {
-        //        "code": "200000",
-        //        "data": {
-        //            "orderId": "619717484f1d010001510cde",
-        //        },
-        //    }
-        //
-        const data = this.safeValue(response, 'data', {});
-        return this.safeOrder({
-            'id': this.safeString(data, 'orderId'),
-            'clientOrderId': undefined,
-            'timestamp': undefined,
-            'datetime': undefined,
-            'lastTradeTimestamp': undefined,
-            'symbol': undefined,
-            'type': undefined,
-            'side': undefined,
-            'price': undefined,
-            'amount': undefined,
-            'cost': undefined,
-            'average': undefined,
-            'filled': undefined,
-            'remaining': undefined,
-            'status': undefined,
-            'fee': undefined,
-            'trades': undefined,
-            'timeInForce': undefined,
-            'postOnly': undefined,
-            'stopPrice': undefined,
-            'triggerPrice': undefined,
-            'info': response,
-        }, market);
+        return this.extend(request, params);
     }
     async cancelOrder(id, symbol = undefined, params = {}) {
         /**
@@ -1701,10 +1736,26 @@ export default class kucoinfutures extends kucoin {
         //         "reduceOnly": false
         //     }
         //
+        // createOrder
+        //
+        //     {
+        //         "orderId": "619717484f1d010001510cde"
+        //     }
+        //
+        // createOrders
+        //
+        //     {
+        //         "orderId": "80465574458560512",
+        //         "clientOid": "5c52e11203aa677f33e491",
+        //         "symbol": "ETHUSDTM",
+        //         "code": "200000",
+        //         "msg": "success"
+        //     }
+        //
         const marketId = this.safeString(order, 'symbol');
         market = this.safeMarket(marketId, market);
         const symbol = market['symbol'];
-        const orderId = this.safeString(order, 'id');
+        const orderId = this.safeString2(order, 'id', 'orderId');
         const type = this.safeString(order, 'type');
         const timestamp = this.safeInteger(order, 'createdAt');
         const datetime = this.iso8601(timestamp);
@@ -1731,9 +1782,12 @@ export default class kucoinfutures extends kucoin {
         // precision reported by their api is 8 d.p.
         // const average = Precise.stringDiv (cost, Precise.stringMul (filled, market['contractSize']));
         // bool
-        const isActive = this.safeValue(order, 'isActive', false);
+        const isActive = this.safeValue(order, 'isActive');
         const cancelExist = this.safeValue(order, 'cancelExist', false);
-        let status = isActive ? 'open' : 'closed';
+        let status = undefined;
+        if (isActive !== undefined) {
+            status = isActive ? 'open' : 'closed';
+        }
         status = cancelExist ? 'canceled' : status;
         let fee = undefined;
         if (feeCost !== undefined) {
@@ -2378,62 +2432,62 @@ export default class kucoinfutures extends kucoin {
         /**
          * @method
          * @name kucoinfutures#fetchFundingRateHistory
+         * @see https://www.kucoin.com/docs/rest/futures-trading/funding-fees/get-public-funding-history#request-url
          * @description fetches historical funding rate prices
          * @param {string} symbol unified symbol of the market to fetch the funding rate history for
          * @param {int} [since] not used by kucuoinfutures
          * @param {int} [limit] the maximum amount of [funding rate structures]{@link https://docs.ccxt.com/#/?id=funding-rate-history-structure} to fetch
          * @param {object} [params] extra parameters specific to the exchange API endpoint
-         * @param {boolean} [params.paginate] default false, when true will automatically paginate by calling this endpoint multiple times. See in the docs all the [availble parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
+         * @param {int} [params.until] end time in ms
          * @returns {object[]} a list of [funding rate structures]{@link https://docs.ccxt.com/#/?id=funding-rate-history-structure}
          */
         if (symbol === undefined) {
             throw new ArgumentsRequired(this.id + ' fetchFundingRateHistory() requires a symbol argument');
         }
         await this.loadMarkets();
-        let paginate = false;
-        [paginate, params] = this.handleOptionAndParams(params, 'fetchFundingRateHistory', 'paginate');
-        if (paginate) {
-            return await this.fetchPaginatedCallDeterministic('fetchFundingRateHistory', symbol, since, limit, '8h', params);
-        }
         const market = this.market(symbol);
         const request = {
             'symbol': market['id'],
+            'from': 0,
+            'to': this.milliseconds(),
         };
-        if (limit !== undefined) {
-            request['maxCount'] = limit;
+        const until = this.safeInteger2(params, 'until', 'till');
+        params = this.omit(params, ['until', 'till']);
+        if (since !== undefined) {
+            request['from'] = since;
+            if (until === undefined) {
+                request['to'] = since + 1000 * 8 * 60 * 60 * 100;
+            }
+        }
+        if (until !== undefined) {
+            request['to'] = until;
+            if (since === undefined) {
+                request['to'] = until - 1000 * 8 * 60 * 60 * 100;
+            }
         }
-        const response = await this.webExchangeGetContractSymbolFundingRates(this.extend(request, params));
+        const response = await this.futuresPublicGetContractFundingRates(this.extend(request, params));
         //
-        //    {
-        //        "success": true,
-        //        "code": "200",
-        //        "msg": "success",
-        //        "retry": false,
-        //        "data": {
-        //            "dataList": [
-        //                {
-        //                    "symbol": "XBTUSDTM",
-        //                    "granularity": 28800000,
-        //                    "timePoint": 1675108800000,
-        //                    "value": 0.0001
-        //                },
-        //                ...
-        //            ],
-        //            "hasMore": true
-        //        }
-        //    }
+        //     {
+        //         "code": "200000",
+        //         "data": [
+        //             {
+        //                 "symbol": "IDUSDTM",
+        //                 "fundingRate": 2.26E-4,
+        //                 "timepoint": 1702296000000
+        //             }
+        //         ]
+        //     }
         //
         const data = this.safeValue(response, 'data');
-        const dataList = this.safeValue(data, 'dataList');
-        return this.parseFundingRateHistories(dataList, market, since, limit);
+        return this.parseFundingRateHistories(data, market, since, limit);
     }
     parseFundingRateHistory(info, market = undefined) {
-        const timestamp = this.safeInteger(info, 'timePoint');
+        const timestamp = this.safeInteger(info, 'timepoint');
         const marketId = this.safeString(info, 'symbol');
         return {
             'info': info,
             'symbol': this.safeSymbol(marketId, market),
-            'fundingRate': this.safeNumber(info, 'value'),
+            'fundingRate': this.safeNumber(info, 'fundingRate'),
             'timestamp': timestamp,
             'datetime': this.iso8601(timestamp),
         };

package/js/src/okx.js

@@ -43,12 +43,16 @@ export default class okx extends Exchange {
                 'createMarketSellOrderWithCost': true,
                 'createOrder': true,
                 'createOrders': true,
+                'createOrderWithTakeProfitAndStopLoss': true,
                 'createPostOnlyOrder': true,
                 'createReduceOnlyOrder': true,
                 'createStopLimitOrder': true,
+                'createStopLossOrder': true,
                 'createStopMarketOrder': true,
                 'createStopOrder': true,
+                'createTakeProfitOrder': true,
                 'createTrailingPercentOrder': true,
+                'createTriggerOrder': true,
                 'editOrder': true,
                 'fetchAccounts': true,
                 'fetchBalance': true,
@@ -2136,17 +2140,14 @@ export default class okx extends Exchange {
         let defaultType = 'Candles';
         if (since !== undefined) {
             const now = this.milliseconds();
-            const difference = now - since;
             const durationInMilliseconds = duration * 1000;
-            // if the since timestamp is more than limit candles back in the past
-            // additional one bar for max offset to round the current day to UTC
-            const calc = (1440 - limit - 1) * durationInMilliseconds;
-            if (difference > calc) {
+            // switch to history candles if since is past the cutoff for current candles
+            const historyBorder = now - ((1440 - 1) * durationInMilliseconds);
+            if (since < historyBorder) {
                 defaultType = 'HistoryCandles';
             }
-            const startTime = Math.max(since - 1, 0);
-            request['before'] = startTime;
-            request['after'] = this.sum(startTime, durationInMilliseconds * limit);
+            request['before'] = since;
+            request['after'] = this.sum(since, durationInMilliseconds * limit);
         }
         const until = this.safeInteger(params, 'until');
         if (until !== undefined) {

package/js/src/pro/htx.js

@@ -933,11 +933,16 @@ export default class htx extends htxRest {
                 // inject trade in existing order by faking an order object
                 const orderId = this.safeString(parsedTrade, 'order');
                 const trades = [parsedTrade];
+                const status = this.parseOrderStatus(this.safeString2(data, 'orderStatus', 'status', 'closed'));
+                const filled = this.safeString(data, 'execAmt');
+                const remaining = this.safeString(data, 'remainAmt');
                 const order = {
                     'id': orderId,
                     'trades': trades,
-                    'status': 'closed',
+                    'status': status,
                     'symbol': market['symbol'],
+                    'filled': this.parseNumber(filled),
+                    'remaining': this.parseNumber(remaining),
                 };
                 parsedOrder = order;
             }

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

@@ -1,5 +1,5 @@
 import wooRest from '../woo.js';
-import type { Int, Str, Strings, OrderBook, Order, Trade, Ticker, Tickers, OHLCV, Balances } from '../base/types.js';
+import type { Int, Str, Strings, OrderBook, Order, Trade, Ticker, Tickers, OHLCV, Balances, Position } from '../base/types.js';
 import Client from '../base/ws/Client.js';
 export default class woo extends wooRest {
     describe(): any;
@@ -24,6 +24,10 @@ export default class woo extends wooRest {
     parseWsOrder(order: any, market?: any): Order;
     handleOrderUpdate(client: Client, message: any): void;
     handleOrder(client: Client, message: any): void;
+    watchPositions(symbols?: Strings, since?: Int, limit?: Int, params?: {}): Promise<Position[]>;
+    setPositionsCache(client: Client, type: any, symbols?: Strings): void;
+    loadPositionsSnapshot(client: any, messageHash: any): Promise<void>;
+    handlePositions(client: any, message: any): void;
     watchBalance(params?: {}): Promise<Balances>;
     handleBalance(client: any, message: any): void;
     handleMessage(client: Client, message: any): any;

package/js/src/pro/woo.js

@@ -7,7 +7,7 @@
 // ----------------------------------------------------------------------------
 import wooRest from '../woo.js';
 import { ExchangeError, AuthenticationError } from '../base/errors.js';
-import { ArrayCacheByTimestamp, ArrayCacheBySymbolById, ArrayCache } from '../base/ws/Cache.js';
+import { ArrayCacheByTimestamp, ArrayCacheBySymbolById, ArrayCache, ArrayCacheBySymbolBySide } from '../base/ws/Cache.js';
 import { Precise } from '../base/Precise.js';
 import { sha256 } from '../static_dependencies/noble-hashes/sha256.js';
 // ----------------------------------------------------------------------------
@@ -24,6 +24,7 @@ export default class woo extends wooRest {
                 'watchTicker': true,
                 'watchTickers': true,
                 'watchTrades': true,
+                'watchPositions': true,
             },
             'urls': {
                 'api': {
@@ -48,6 +49,10 @@ export default class woo extends wooRest {
                 'tradesLimit': 1000,
                 'ordersLimit': 1000,
                 'requestId': {},
+                'watchPositions': {
+                    'fetchPositionsSnapshot': true,
+                    'awaitPositionsSnapshot': true, // whether to wait for the positions snapshot before providing updates
+                },
             },
             'streaming': {
                 'ping': this.ping,
@@ -606,6 +611,126 @@ export default class woo extends wooRest {
             client.resolve(this.orders, messageHashSymbol);
         }
     }
+    async watchPositions(symbols = undefined, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name woo#watchPositions
+         * @see https://docs.woo.org/#position-push
+         * @description watch all open positions
+         * @param {string[]|undefined} symbols list of unified market symbols
+         * @param {object} params extra parameters specific to the exchange API endpoint
+         * @returns {object[]} a list of [position structure]{@link https://docs.ccxt.com/en/latest/manual.html#position-structure}
+         */
+        await this.loadMarkets();
+        let messageHash = '';
+        symbols = this.marketSymbols(symbols);
+        if (!this.isEmpty(symbols)) {
+            messageHash = '::' + symbols.join(',');
+        }
+        messageHash = 'positions' + messageHash;
+        const url = this.urls['api']['ws']['private'] + '/' + this.uid;
+        const client = this.client(url);
+        this.setPositionsCache(client, symbols);
+        const fetchPositionsSnapshot = this.handleOption('watchPositions', 'fetchPositionsSnapshot', true);
+        const awaitPositionsSnapshot = this.safeValue('watchPositions', 'awaitPositionsSnapshot', true);
+        if (fetchPositionsSnapshot && awaitPositionsSnapshot && this.positions === undefined) {
+            const snapshot = await client.future('fetchPositionsSnapshot');
+            return this.filterBySymbolsSinceLimit(snapshot, symbols, since, limit, true);
+        }
+        const request = {
+            'event': 'subscribe',
+            'topic': 'position',
+        };
+        const newPositions = await this.watchPrivate(messageHash, request, params);
+        if (this.newUpdates) {
+            return newPositions;
+        }
+        return this.filterBySymbolsSinceLimit(this.positions, symbols, since, limit, true);
+    }
+    setPositionsCache(client, type, symbols = undefined) {
+        const fetchPositionsSnapshot = this.handleOption('watchPositions', 'fetchPositionsSnapshot', false);
+        if (fetchPositionsSnapshot) {
+            const messageHash = 'fetchPositionsSnapshot';
+            if (!(messageHash in client.futures)) {
+                client.future(messageHash);
+                this.spawn(this.loadPositionsSnapshot, client, messageHash);
+            }
+        }
+        else {
+            this.positions = new ArrayCacheBySymbolBySide();
+        }
+    }
+    async loadPositionsSnapshot(client, messageHash) {
+        const positions = await this.fetchPositions();
+        this.positions = new ArrayCacheBySymbolBySide();
+        const cache = this.positions;
+        for (let i = 0; i < positions.length; i++) {
+            const position = positions[i];
+            const contracts = this.safeNumber(position, 'contracts', 0);
+            if (contracts > 0) {
+                cache.append(position);
+            }
+        }
+        // don't remove the future from the .futures cache
+        const future = client.futures[messageHash];
+        future.resolve(cache);
+        client.resolve(cache, 'positions');
+    }
+    handlePositions(client, message) {
+        //
+        //    {
+        //        "topic":"position",
+        //        "ts":1705292345255,
+        //        "data":{
+        //           "positions":{
+        //              "PERP_LTC_USDT":{
+        //                 "holding":1,
+        //                 "pendingLongQty":0,
+        //                 "pendingShortQty":0,
+        //                 "averageOpenPrice":71.53,
+        //                 "pnl24H":0,
+        //                 "fee24H":0.07153,
+        //                 "settlePrice":71.53,
+        //                 "markPrice":71.32098452065145,
+        //                 "version":7886,
+        //                 "openingTime":1705292304267,
+        //                 "pnl24HPercentage":0,
+        //                 "adlQuantile":1,
+        //                 "positionSide":"BOTH"
+        //              }
+        //           }
+        //        }
+        //    }
+        //
+        const data = this.safeValue(message, 'data', {});
+        const rawPositions = this.safeValue(data, 'positions', {});
+        const postitionsIds = Object.keys(rawPositions);
+        if (this.positions === undefined) {
+            this.positions = new ArrayCacheBySymbolBySide();
+        }
+        const cache = this.positions;
+        const newPositions = [];
+        for (let i = 0; i < postitionsIds.length; i++) {
+            const marketId = postitionsIds[i];
+            const market = this.safeMarket(marketId);
+            const rawPosition = rawPositions[marketId];
+            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);
+            }
+        }
+        client.resolve(newPositions, 'positions');
+    }
     async watchBalance(params = {}) {
         /**
          * @method
@@ -689,6 +814,7 @@ export default class woo extends wooRest {
             'executionreport': this.handleOrderUpdate,
             'trade': this.handleTrade,
             'balance': this.handleBalance,
+            'position': this.handlePositions,
         };
         const event = this.safeString(message, 'event');
         let method = this.safeValue(methods, event);

package/js/src/woo.js

@@ -45,12 +45,16 @@ export default class woo extends Exchange {
                 'createMarketOrderWithCost': false,
                 'createMarketSellOrderWithCost': false,
                 'createOrder': true,
+                'createOrderWithTakeProfitAndStopLoss': true,
                 'createReduceOnlyOrder': true,
                 'createStopLimitOrder': false,
+                'createStopLossOrder': true,
                 'createStopMarketOrder': false,
                 'createStopOrder': false,
+                'createTakeProfitOrder': true,
                 'createTrailingAmountOrder': true,
                 'createTrailingPercentOrder': true,
+                'createTriggerOrder': true,
                 'fetchAccounts': true,
                 'fetchBalance': true,
                 'fetchCanceledOrders': false,
@@ -769,7 +773,7 @@ export default class woo extends Exchange {
     async createTrailingAmountOrder(symbol, type, side, amount, price = undefined, trailingAmount = undefined, trailingTriggerPrice = undefined, params = {}) {
         /**
          * @method
-         * @name createTrailingAmountOrder
+         * @name woo#createTrailingAmountOrder
          * @description create a trailing order by providing the symbol, type, side, amount, price and trailingAmount
          * @param {string} symbol unified symbol of the market to create an order in
          * @param {string} type 'market' or 'limit'
@@ -794,7 +798,7 @@ export default class woo extends Exchange {
     async createTrailingPercentOrder(symbol, type, side, amount, price = undefined, trailingPercent = undefined, trailingTriggerPrice = undefined, params = {}) {
         /**
          * @method
-         * @name createTrailingPercentOrder
+         * @name woo#createTrailingPercentOrder
          * @description create a trailing order by providing the symbol, type, side, amount, price and trailingPercent
          * @param {string} symbol unified symbol of the market to create an order in
          * @param {string} type 'market' or 'limit'

package/package.json

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