ccxt 4.2.12 → 4.2.14

package/dist/cjs/js/src/lbank.js

@@ -929,13 +929,17 @@ class lbank extends lbank$1 {
         else {
             request['size'] = 600; // max
         }
-        let method = this.safeString(params, 'method');
+        const options = this.safeValue(this.options, 'fetchTrades', {});
+        const defaultMethod = this.safeString(options, 'method', 'spotPublicGetTrades');
+        const method = this.safeString(params, 'method', defaultMethod);
         params = this.omit(params, 'method');
-        if (method === undefined) {
-            const options = this.safeValue(this.options, 'fetchTrades', {});
-            method = this.safeString(options, 'method', 'spotPublicGetTrades');
+        let response = undefined;
+        if (method === 'spotPublicGetSupplementTrades') {
+            response = await this.spotPublicGetSupplementTrades(this.extend(request, params));
+        }
+        else {
+            response = await this.spotPublicGetTrades(this.extend(request, params));
         }
-        const response = await this[method](this.extend(request, params));
         //
         //      {
         //          "result":"true",
@@ -1172,12 +1176,19 @@ class lbank extends lbank$1 {
          * @returns {object} a [balance structure]{@link https://docs.ccxt.com/#/?id=balance-structure}
          */
         await this.loadMarkets();
-        let method = this.safeString(params, 'method');
-        if (method === undefined) {
-            const options = this.safeValue(this.options, 'fetchBalance', {});
-            method = this.safeString(options, 'method', 'spotPrivatePostSupplementUserInfo');
+        const options = this.safeValue(this.options, 'fetchBalance', {});
+        const defaultMethod = this.safeString(options, 'method', 'spotPrivatePostSupplementUserInfo');
+        const method = this.safeString(params, 'method', defaultMethod);
+        let response = undefined;
+        if (method === 'spotPrivatePostSupplementUserInfoAccount') {
+            response = await this.spotPrivatePostSupplementUserInfoAccount();
+        }
+        else if (method === 'spotPrivatePostUserInfo') {
+            response = await this.spotPrivatePostUserInfo();
+        }
+        else {
+            response = await this.spotPrivatePostSupplementUserInfo();
         }
-        const response = await this[method]();
         //
         //    {
         //        "result": "true",
@@ -1362,14 +1373,17 @@ class lbank extends lbank$1 {
         if (clientOrderId !== undefined) {
             request['custom_id'] = clientOrderId;
         }
-        let method = undefined;
-        method = this.safeString(params, 'method');
+        const options = this.safeValue(this.options, 'createOrder', {});
+        const defaultMethod = this.safeString(options, 'method', 'spotPrivatePostSupplementCreateOrder');
+        const method = this.safeString(params, 'method', defaultMethod);
         params = this.omit(params, 'method');
-        if (method === undefined) {
-            const options = this.safeValue(this.options, 'createOrder', {});
-            method = this.safeString(options, 'method', 'spotPrivatePostSupplementCreateOrder');
+        let response = undefined;
+        if (method === 'spotPrivatePostCreateOrder') {
+            response = await this.spotPrivatePostCreateOrder(this.extend(request, params));
+        }
+        else {
+            response = await this.spotPrivatePostSupplementCreateOrder(this.extend(request, params));
         }
-        const response = await this[method](this.extend(request, params));
         //
         //      {
         //          "result":true,
@@ -1904,13 +1918,18 @@ class lbank extends lbank$1 {
          * @returns {object} an [address structure]{@link https://docs.ccxt.com/#/?id=address-structure}
          */
         await this.loadMarkets();
-        let method = this.safeString(params, 'method');
+        const options = this.safeValue(this.options, 'fetchDepositAddress', {});
+        const defaultMethod = this.safeString(options, 'method', 'fetchDepositAddressDefault');
+        const method = this.safeString(params, 'method', defaultMethod);
         params = this.omit(params, 'method');
-        if (method === undefined) {
-            const options = this.safeValue(this.options, 'fetchDepositAddress', {});
-            method = this.safeString(options, 'method', 'fetchDepositAddressDefault');
+        let response = undefined;
+        if (method === 'fetchDepositAddressSupplement') {
+            response = await this.fetchDepositAddressSupplement(code, params);
         }
-        return await this[method](code, params);
+        else {
+            response = await this.fetchDepositAddressDefault(code, params);
+        }
+        return response;
     }
     async fetchDepositAddressDefault(code, params = {}) {
         await this.loadMarkets();
@@ -2282,13 +2301,16 @@ class lbank extends lbank$1 {
         const isAuthorized = this.checkRequiredCredentials(false);
         let result = undefined;
         if (isAuthorized === true) {
-            let method = this.safeString(params, 'method');
+            const options = this.safeValue(this.options, 'fetchTransactionFees', {});
+            const defaultMethod = this.safeString(options, 'method', 'fetchPrivateTransactionFees');
+            const method = this.safeString(params, 'method', defaultMethod);
             params = this.omit(params, 'method');
-            if (method === undefined) {
-                const options = this.safeValue(this.options, 'fetchTransactionFees', {});
-                method = this.safeString(options, 'method', 'fetchPrivateTransactionFees');
+            if (method === 'fetchPublicTransactionFees') {
+                result = await this.fetchPublicTransactionFees(params);
+            }
+            else {
+                result = await this.fetchPrivateTransactionFees(params);
             }
-            result = await this[method](params);
         }
         else {
             result = await this.fetchPublicTransactionFees(params);
@@ -2426,19 +2448,23 @@ class lbank extends lbank$1 {
          */
         await this.loadMarkets();
         const isAuthorized = this.checkRequiredCredentials(false);
-        let method = undefined;
+        const response = undefined;
         if (isAuthorized === true) {
-            method = this.safeString(params, 'method');
+            const options = this.safeValue(this.options, 'fetchDepositWithdrawFees', {});
+            const defaultMethod = this.safeString(options, 'method', 'fetchPrivateDepositWithdrawFees');
+            const method = this.safeString(params, 'method', defaultMethod);
             params = this.omit(params, 'method');
-            if (method === undefined) {
-                const options = this.safeValue(this.options, 'fetchDepositWithdrawFees', {});
-                method = this.safeString(options, 'method', 'fetchPrivateDepositWithdrawFees');
+            if (method === 'fetchPublicDepositWithdrawFees') {
+                await this.fetchPublicDepositWithdrawFees(codes, params);
+            }
+            else {
+                await this.fetchPrivateDepositWithdrawFees(codes, params);
             }
         }
         else {
-            method = 'fetchPublicDepositWithdrawFees';
+            await this.fetchPublicDepositWithdrawFees(codes, params);
         }
-        return await this[method](codes, params);
+        return response;
     }
     async fetchPrivateDepositWithdrawFees(codes = undefined, params = {}) {
         // complete response

package/dist/cjs/js/src/oceanex.js

@@ -472,7 +472,7 @@ class oceanex extends oceanex$1 {
             'market': market['id'],
         };
         if (limit !== undefined) {
-            request['limit'] = limit;
+            request['limit'] = Math.min(limit, 1000);
         }
         const response = await this.publicGetTrades(this.extend(request, params));
         //

package/dist/cjs/js/src/okx.js

@@ -38,14 +38,18 @@ class okx extends okx$1 {
                 'createDepositAddress': false,
                 'createMarketBuyOrderWithCost': true,
                 'createMarketSellOrderWithCost': true,
-                'createTrailingPercentOrder': true,
                 'createOrder': true,
                 'createOrders': true,
+                'createOrderWithTakeProfitAndStopLoss': true,
                 'createPostOnlyOrder': true,
                 'createReduceOnlyOrder': true,
+                'createStopLossOrder': true,
                 'createStopLimitOrder': true,
                 'createStopMarketOrder': true,
                 'createStopOrder': true,
+                'createTakeProfitOrder': true,
+                'createTrailingPercentOrder': true,
+                'createTriggerOrder': true,
                 'editOrder': true,
                 'fetchAccounts': true,
                 'fetchBalance': true,
@@ -259,6 +263,7 @@ class okx extends okx$1 {
                         'sprd/order': 1 / 3,
                         'sprd/orders-pending': 1 / 3,
                         'sprd/orders-history': 1 / 2,
+                        'sprd/orders-history-archive': 1 / 2,
                         'sprd/trades': 1 / 3,
                         // trade
                         'trade/order': 1 / 3,
@@ -2132,17 +2137,14 @@ class okx extends okx$1 {
         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/dist/cjs/js/src/phemex.js

@@ -452,7 +452,7 @@ class phemex extends phemex$1 {
                 },
             },
             'options': {
-                'brokerId': 'CCXT',
+                'brokerId': 'CCXT123456',
                 'x-phemex-request-expiry': 60,
                 'createOrderByQuoteRequiresPrice': true,
                 'networks': {
@@ -2477,7 +2477,7 @@ class phemex extends phemex$1 {
         const takeProfit = this.safeValue(params, 'takeProfit');
         const takeProfitDefined = (takeProfit !== undefined);
         if (clientOrderId === undefined) {
-            const brokerId = this.safeString(this.options, 'brokerId');
+            const brokerId = this.safeString(this.options, 'brokerId', 'CCXT123456');
             if (brokerId !== undefined) {
                 request['clOrdID'] = brokerId + this.uuid16();
             }
@@ -4273,6 +4273,13 @@ class phemex extends phemex$1 {
             };
             let payload = '';
             if (method === 'POST') {
+                const isOrderPlacement = (path === 'g-orders') || (path === 'spot/orders') || (path === 'orders');
+                if (isOrderPlacement) {
+                    if (this.safeString(params, 'clOrdID') === undefined) {
+                        const id = this.safeString(this.options, 'brokerId', 'CCXT123456');
+                        params['clOrdID'] = id + this.uuid16();
+                    }
+                }
                 payload = this.json(params);
                 body = payload;
                 headers['Content-Type'] = 'application/json';

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

@@ -542,7 +542,7 @@ class kraken extends kraken$1 {
             ],
             'subscription': {
                 'name': name,
-                'interval': this.safeString(this.timeframes, timeframe, timeframe),
+                'interval': this.safeValue(this.timeframes, timeframe, timeframe),
             },
         };
         const request = this.deepExtend(subscribe, params);

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

@@ -20,6 +20,7 @@ class okx extends okx$1 {
                 'watchOrderBookForSymbols': true,
                 'watchBalance': true,
                 'watchOHLCV': true,
+                'watchOHLCVForSymbols': true,
                 'watchOrders': true,
                 'watchMyTrades': true,
                 'watchPositions': true,
@@ -356,6 +357,50 @@ class okx extends okx$1 {
         }
         return this.filterBySinceLimit(ohlcv, since, limit, 0, true);
     }
+    async watchOHLCVForSymbols(symbolsAndTimeframes, since = undefined, limit = undefined, params = {}) {
+        /**
+         * @method
+         * @name okx#watchOHLCVForSymbols
+         * @description watches historical candlestick data containing the open, high, low, and close price, and the volume of a market
+         * @param {string[][]} symbolsAndTimeframes array of arrays containing unified symbols and timeframes to fetch OHLCV data for, example [['BTC/USDT', '1m'], ['LTC/USDT', '5m']]
+         * @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
+         */
+        const symbolsLength = symbolsAndTimeframes.length;
+        if (symbolsLength === 0 || !Array.isArray(symbolsAndTimeframes[0])) {
+            throw new errors.ArgumentsRequired(this.id + " watchOHLCVForSymbols() requires a an array of symbols and timeframes, like  [['BTC/USDT', '1m'], ['LTC/USDT', '5m']]");
+        }
+        await this.loadMarkets();
+        const topics = [];
+        const messageHashes = [];
+        for (let i = 0; i < symbolsAndTimeframes.length; i++) {
+            const symbolAndTimeframe = symbolsAndTimeframes[i];
+            const sym = symbolAndTimeframe[0];
+            const tf = symbolAndTimeframe[1];
+            const marketId = this.marketId(sym);
+            const interval = this.safeString(this.timeframes, tf, tf);
+            const channel = 'candle' + interval;
+            const topic = {
+                'channel': channel,
+                'instId': marketId,
+            };
+            topics.push(topic);
+            messageHashes.push('multi:' + channel + ':' + sym);
+        }
+        const request = {
+            'op': 'subscribe',
+            'args': topics,
+        };
+        const url = this.getUrl('candle', 'public');
+        const [symbol, timeframe, candles] = await this.watchMultiple(url, messageHashes, request, messageHashes);
+        if (this.newUpdates) {
+            limit = candles.getLimit(symbol, limit);
+        }
+        const filtered = this.filterBySinceLimit(candles, since, limit, 0, true);
+        return this.createOHLCVObject(symbol, timeframe, filtered);
+    }
     handleOHLCV(client, message) {
         //
         //     {
@@ -378,7 +423,7 @@ class okx extends okx$1 {
         const data = this.safeValue(message, 'data', []);
         const marketId = this.safeString(arg, 'instId');
         const market = this.safeMarket(marketId);
-        const symbol = market['id'];
+        const symbol = market['symbol'];
         const interval = channel.replace('candle', '');
         // use a reverse lookup in a static map instead
         const timeframe = this.findTimeframe(interval);
@@ -392,8 +437,13 @@ class okx extends okx$1 {
                 this.ohlcvs[symbol][timeframe] = stored;
             }
             stored.append(parsed);
-            const messageHash = channel + ':' + marketId;
+            const messageHash = channel + ':' + market['id'];
             client.resolve(stored, messageHash);
+            // for multiOHLCV we need special object, as opposed to other "multi"
+            // methods, because OHLCV response item does not contain symbol
+            // or timeframe, thus otherwise it would be unrecognizable
+            const messageHashForMulti = 'multi:' + channel + ':' + symbol;
+            client.resolve([symbol, timeframe, stored], messageHashForMulti);
         }
     }
     async watchOrderBook(symbol, limit = undefined, params = {}) {

package/dist/cjs/js/src/probit.js

@@ -776,7 +776,6 @@ class probit extends probit$1 {
         const market = this.market(symbol);
         const request = {
             'market_id': market['id'],
-            'limit': 100,
             'start_time': '1970-01-01T00:00:00.000Z',
             'end_time': this.iso8601(this.milliseconds()),
         };
@@ -784,7 +783,10 @@ class probit extends probit$1 {
             request['start_time'] = this.iso8601(since);
         }
         if (limit !== undefined) {
-            request['limit'] = Math.min(limit, 10000);
+            request['limit'] = Math.min(limit, 1000);
+        }
+        else {
+            request['limit'] = 1000; // required to set any value
         }
         const response = await this.publicGetTrade(this.extend(request, params));
         //

package/dist/cjs/js/src/wavesexchange.js

@@ -2092,7 +2092,7 @@ class wavesexchange extends wavesexchange$1 {
             'priceAsset': market['quoteId'],
         };
         if (limit !== undefined) {
-            request['limit'] = limit;
+            request['limit'] = Math.min(limit, 100);
         }
         if (since !== undefined) {
             request['timeStart'] = since;

package/dist/cjs/js/src/woo.js

@@ -41,13 +41,17 @@ class woo extends woo$1 {
                 'createMarketOrder': false,
                 'createMarketOrderWithCost': false,
                 'createMarketSellOrderWithCost': false,
-                'createTrailingAmountOrder': true,
-                'createTrailingPercentOrder': true,
                 'createOrder': true,
                 'createReduceOnlyOrder': true,
                 'createStopLimitOrder': false,
                 'createStopMarketOrder': false,
                 'createStopOrder': false,
+                'createTrailingAmountOrder': true,
+                'createTrailingPercentOrder': true,
+                'createTriggerOrder': true,
+                'createTakeProfitOrder': true,
+                'createStopLossOrder': true,
+                'createOrderWithTakeProfitAndStopLoss': true,
                 'fetchAccounts': true,
                 'fetchBalance': true,
                 'fetchCanceledOrders': false,
@@ -763,6 +767,56 @@ class woo extends woo$1 {
         params['createMarketBuyOrderRequiresPrice'] = false;
         return await this.createOrder(symbol, 'market', 'buy', cost, undefined, params);
     }
+    async createTrailingAmountOrder(symbol, type, side, amount, price = undefined, trailingAmount = undefined, trailingTriggerPrice = undefined, params = {}) {
+        /**
+         * @method
+         * @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'
+         * @param {string} side 'buy' or 'sell'
+         * @param {float} amount how much you want to trade in units of the base currency, or number of contracts
+         * @param {float} [price] the price for the order to be filled at, in units of the quote currency, ignored in market orders
+         * @param {float} trailingAmount the quote amount to trail away from the current market price
+         * @param {float} trailingTriggerPrice the price to activate a trailing order, default uses the price argument
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        if (trailingAmount === undefined) {
+            throw new errors.ArgumentsRequired(this.id + ' createTrailingAmountOrder() requires a trailingAmount argument');
+        }
+        if (trailingTriggerPrice === undefined) {
+            throw new errors.ArgumentsRequired(this.id + ' createTrailingAmountOrder() requires a trailingTriggerPrice argument');
+        }
+        params['trailingAmount'] = trailingAmount;
+        params['trailingTriggerPrice'] = trailingTriggerPrice;
+        return await this.createOrder(symbol, type, side, amount, price, params);
+    }
+    async createTrailingPercentOrder(symbol, type, side, amount, price = undefined, trailingPercent = undefined, trailingTriggerPrice = undefined, params = {}) {
+        /**
+         * @method
+         * @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'
+         * @param {string} side 'buy' or 'sell'
+         * @param {float} amount how much you want to trade in units of the base currency, or number of contracts
+         * @param {float} [price] the price for the order to be filled at, in units of the quote currency, ignored in market orders
+         * @param {float} trailingPercent the percent to trail away from the current market price
+         * @param {float} trailingTriggerPrice the price to activate a trailing order, default uses the price argument
+         * @param {object} [params] extra parameters specific to the exchange API endpoint
+         * @returns {object} an [order structure]{@link https://docs.ccxt.com/#/?id=order-structure}
+         */
+        if (trailingPercent === undefined) {
+            throw new errors.ArgumentsRequired(this.id + ' createTrailingPercentOrder() requires a trailingPercent argument');
+        }
+        if (trailingTriggerPrice === undefined) {
+            throw new errors.ArgumentsRequired(this.id + ' createTrailingPercentOrder() requires a trailingTriggerPrice argument');
+        }
+        params['trailingPercent'] = trailingPercent;
+        params['trailingTriggerPrice'] = trailingTriggerPrice;
+        return await this.createOrder(symbol, type, side, amount, price, params);
+    }
     async createOrder(symbol, type, side, amount, price = undefined, params = {}) {
         /**
          * @method

package/js/ccxt.d.ts

@@ -4,7 +4,7 @@ import * as functions from './src/base/functions.js';
 import * as errors from './src/base/errors.js';
 import type { Market, Trade, Fee, Ticker, OrderBook, Order, Transaction, Tickers, Currency, Balance, DepositAddress, WithdrawalResponse, DepositAddressResponse, OHLCV, Balances, PartialBalances, Dictionary, MinMax, Position, FundingRateHistory, Liquidation, FundingHistory, MarginMode, Greeks } from './src/base/types.js';
 import { BaseError, ExchangeError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, MarginModeAlreadySet, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, NotSupported, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout, AuthenticationError, AddressPending, NoChange } from './src/base/errors.js';
-declare const version = "4.2.11";
+declare const version = "4.2.13";
 import ace from './src/ace.js';
 import alpaca from './src/alpaca.js';
 import ascendex from './src/ascendex.js';

package/js/ccxt.js

@@ -38,7 +38,7 @@ import * as errors from './src/base/errors.js';
 import { BaseError, ExchangeError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, MarginModeAlreadySet, BadResponse, NullResponse, InsufficientFunds, InvalidAddress, InvalidOrder, OrderNotFound, OrderNotCached, CancelPending, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, NotSupported, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, RequestTimeout, AuthenticationError, AddressPending, NoChange } from './src/base/errors.js';
 //-----------------------------------------------------------------------------
 // this is updated by vss.js when building
-const version = '4.2.12';
+const version = '4.2.14';
 Exchange.ccxtVersion = version;
 //-----------------------------------------------------------------------------
 import ace from './src/ace.js';

package/js/src/abstract/bigone.d.ts

@@ -22,6 +22,7 @@ interface Exchange {
     privatePostOrdersCancel(params?: {}): Promise<implicitReturnType>;
     privatePostWithdrawals(params?: {}): Promise<implicitReturnType>;
     privatePostTransfer(params?: {}): Promise<implicitReturnType>;
+    contractPublicGetSymbols(params?: {}): Promise<implicitReturnType>;
     contractPublicGetInstruments(params?: {}): Promise<implicitReturnType>;
     contractPublicGetDepthSymbolSnapshot(params?: {}): Promise<implicitReturnType>;
     contractPublicGetInstrumentsDifference(params?: {}): Promise<implicitReturnType>;

package/js/src/abstract/bingx.d.ts

@@ -9,6 +9,7 @@ interface Exchange {
     spotV1PrivateGetTradeQuery(params?: {}): Promise<implicitReturnType>;
     spotV1PrivateGetTradeOpenOrders(params?: {}): Promise<implicitReturnType>;
     spotV1PrivateGetTradeHistoryOrders(params?: {}): Promise<implicitReturnType>;
+    spotV1PrivateGetTradeMyTrades(params?: {}): Promise<implicitReturnType>;
     spotV1PrivateGetUserCommissionRate(params?: {}): Promise<implicitReturnType>;
     spotV1PrivateGetAccountBalance(params?: {}): Promise<implicitReturnType>;
     spotV1PrivatePostTradeOrder(params?: {}): Promise<implicitReturnType>;
@@ -38,6 +39,7 @@ interface Exchange {
     swapV2PrivateGetUserPositions(params?: {}): Promise<implicitReturnType>;
     swapV2PrivateGetUserIncome(params?: {}): Promise<implicitReturnType>;
     swapV2PrivateGetTradeOpenOrders(params?: {}): Promise<implicitReturnType>;
+    swapV2PrivateGetTradeOpenOrder(params?: {}): Promise<implicitReturnType>;
     swapV2PrivateGetTradeOrder(params?: {}): Promise<implicitReturnType>;
     swapV2PrivateGetTradeMarginType(params?: {}): Promise<implicitReturnType>;
     swapV2PrivateGetTradeLeverage(params?: {}): Promise<implicitReturnType>;

package/js/src/abstract/kucoin.d.ts

@@ -149,6 +149,7 @@ interface Exchange {
     futuresPublicGetPremiumQuery(params?: {}): Promise<implicitReturnType>;
     futuresPublicGetTradeStatistics(params?: {}): Promise<implicitReturnType>;
     futuresPublicGetFundingRateSymbolCurrent(params?: {}): Promise<implicitReturnType>;
+    futuresPublicGetContractFundingRates(params?: {}): Promise<implicitReturnType>;
     futuresPublicGetTimestamp(params?: {}): Promise<implicitReturnType>;
     futuresPublicGetStatus(params?: {}): Promise<implicitReturnType>;
     futuresPublicGetLevel2MessageQuery(params?: {}): Promise<implicitReturnType>;
@@ -167,13 +168,16 @@ interface Exchange {
     futuresPrivateGetOpenOrderStatistics(params?: {}): Promise<implicitReturnType>;
     futuresPrivateGetPosition(params?: {}): Promise<implicitReturnType>;
     futuresPrivateGetPositions(params?: {}): Promise<implicitReturnType>;
+    futuresPrivateGetMarginMaxWithdrawMargin(params?: {}): Promise<implicitReturnType>;
     futuresPrivateGetContractsRiskLimitSymbol(params?: {}): Promise<implicitReturnType>;
     futuresPrivateGetFundingHistory(params?: {}): Promise<implicitReturnType>;
     futuresPrivatePostTransferOut(params?: {}): Promise<implicitReturnType>;
     futuresPrivatePostTransferIn(params?: {}): Promise<implicitReturnType>;
     futuresPrivatePostOrders(params?: {}): Promise<implicitReturnType>;
     futuresPrivatePostOrdersTest(params?: {}): Promise<implicitReturnType>;
+    futuresPrivatePostOrdersMulti(params?: {}): Promise<implicitReturnType>;
     futuresPrivatePostPositionMarginAutoDepositStatus(params?: {}): Promise<implicitReturnType>;
+    futuresPrivatePostMarginWithdrawMargin(params?: {}): Promise<implicitReturnType>;
     futuresPrivatePostPositionMarginDepositMargin(params?: {}): Promise<implicitReturnType>;
     futuresPrivatePostPositionRiskLimitLevelChange(params?: {}): Promise<implicitReturnType>;
     futuresPrivatePostBulletPrivate(params?: {}): Promise<implicitReturnType>;

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

@@ -149,6 +149,7 @@ interface kucoin {
     futuresPublicGetPremiumQuery(params?: {}): Promise<implicitReturnType>;
     futuresPublicGetTradeStatistics(params?: {}): Promise<implicitReturnType>;
     futuresPublicGetFundingRateSymbolCurrent(params?: {}): Promise<implicitReturnType>;
+    futuresPublicGetContractFundingRates(params?: {}): Promise<implicitReturnType>;
     futuresPublicGetTimestamp(params?: {}): Promise<implicitReturnType>;
     futuresPublicGetStatus(params?: {}): Promise<implicitReturnType>;
     futuresPublicGetLevel2MessageQuery(params?: {}): Promise<implicitReturnType>;
@@ -171,6 +172,7 @@ interface kucoin {
     futuresPrivateGetOpenOrderStatistics(params?: {}): Promise<implicitReturnType>;
     futuresPrivateGetPosition(params?: {}): Promise<implicitReturnType>;
     futuresPrivateGetPositions(params?: {}): Promise<implicitReturnType>;
+    futuresPrivateGetMarginMaxWithdrawMargin(params?: {}): Promise<implicitReturnType>;
     futuresPrivateGetContractsRiskLimitSymbol(params?: {}): Promise<implicitReturnType>;
     futuresPrivateGetFundingHistory(params?: {}): Promise<implicitReturnType>;
     futuresPrivateGetDepositAddress(params?: {}): Promise<implicitReturnType>;
@@ -183,7 +185,9 @@ interface kucoin {
     futuresPrivatePostTransferIn(params?: {}): Promise<implicitReturnType>;
     futuresPrivatePostOrders(params?: {}): Promise<implicitReturnType>;
     futuresPrivatePostOrdersTest(params?: {}): Promise<implicitReturnType>;
+    futuresPrivatePostOrdersMulti(params?: {}): Promise<implicitReturnType>;
     futuresPrivatePostPositionMarginAutoDepositStatus(params?: {}): Promise<implicitReturnType>;
+    futuresPrivatePostMarginWithdrawMargin(params?: {}): Promise<implicitReturnType>;
     futuresPrivatePostPositionMarginDepositMargin(params?: {}): Promise<implicitReturnType>;
     futuresPrivatePostPositionRiskLimitLevelChange(params?: {}): Promise<implicitReturnType>;
     futuresPrivatePostBulletPrivate(params?: {}): Promise<implicitReturnType>;

package/js/src/abstract/okx.d.ts

@@ -81,6 +81,7 @@ interface Exchange {
     privateGetSprdOrder(params?: {}): Promise<implicitReturnType>;
     privateGetSprdOrdersPending(params?: {}): Promise<implicitReturnType>;
     privateGetSprdOrdersHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetSprdOrdersHistoryArchive(params?: {}): Promise<implicitReturnType>;
     privateGetSprdTrades(params?: {}): Promise<implicitReturnType>;
     privateGetTradeOrder(params?: {}): Promise<implicitReturnType>;
     privateGetTradeOrdersPending(params?: {}): Promise<implicitReturnType>;

package/js/src/base/Exchange.d.ts

@@ -303,13 +303,17 @@ export default class Exchange {
             createMarketOrderWithCost: any;
             createMarketSellOrderWithCost: any;
             createOrders: any;
+            createOrderWithTakeProfitAndStopLoss: any;
             createPostOnlyOrder: any;
             createReduceOnlyOrder: any;
+            createStopLossOrder: any;
             createStopOrder: any;
             createStopLimitOrder: any;
             createStopMarketOrder: any;
+            createTakeProfitOrder: any;
             createTrailingAmountOrder: any;
             createTrailingPercentOrder: any;
+            createTriggerOrder: any;
             createOrderWs: any;
             editOrderWs: any;
             fetchOpenOrdersWs: any;
@@ -778,6 +782,10 @@ export default class Exchange {
     createMarketOrderWithCost(symbol: string, side: OrderSide, cost: any, params?: {}): Promise<Order>;
     createMarketBuyOrderWithCost(symbol: string, cost: any, params?: {}): Promise<Order>;
     createMarketSellOrderWithCost(symbol: string, cost: any, params?: {}): Promise<Order>;
+    createTriggerOrder(symbol: string, type: OrderType, side: OrderSide, amount: any, price?: any, triggerPrice?: any, params?: {}): Promise<Order>;
+    createStopLossOrder(symbol: string, type: OrderType, side: OrderSide, amount: any, price?: any, stopLossPrice?: any, params?: {}): Promise<Order>;
+    createTakeProfitOrder(symbol: string, type: OrderType, side: OrderSide, amount: any, price?: any, takeProfitPrice?: any, params?: {}): Promise<Order>;
+    createOrderWithTakeProfitAndStopLoss(symbol: string, type: OrderType, side: OrderSide, amount: any, price?: any, takeProfit?: any, stopLoss?: any, params?: {}): Promise<Order>;
     createOrders(orders: OrderRequest[], params?: {}): Promise<Order[]>;
     createOrderWs(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: number, params?: {}): Promise<Order>;
     cancelOrder(id: string, symbol?: string, params?: {}): Promise<any>;