ccxt 4.5.36 → 4.5.38

package/dist/cjs/src/krakenfutures.js

@@ -1680,7 +1680,9 @@ class krakenfutures extends krakenfutures$1["default"] {
             'filled': 'closed',
             'notFound': 'rejected',
             'untouched': 'open',
-            'partiallyFilled': 'open', // the size of the order is partially but not entirely filled
+            'partiallyFilled': 'open',
+            'ENTERED_BOOK': 'open',
+            'FULLY_EXECUTED': 'closed',
         };
         return this.safeString(statuses, status, status);
     }
@@ -1919,6 +1921,72 @@ class krakenfutures extends krakenfutures$1["default"] {
         //     status: 'closed'
         //   }
         //
+        // order: {
+        //     type: 'ORDER',
+        //     orderId: 'a111f276-95fd-47fc-b77b-709c5ab2e9e1',
+        //     cliOrdId: null,
+        //     symbol: 'PF_LTCUSD',
+        //     side: 'buy',
+        //     quantity: '0.1',
+        //     filled: '0',
+        //     limitPrice: '40',
+        //     reduceOnly: false,
+        //     timestamp: '2026-02-13T12:09:03.738Z',
+        //     lastUpdateTimestamp: '2026-02-13T12:09:03.738Z'
+        // },
+        //     status: 'ENTERED_BOOK',
+        //     updateReason: null,
+        //     error: null
+        // }
+        //
+        const orderDictFromFetchOrder = this.safeDict(order, 'order');
+        if (orderDictFromFetchOrder !== undefined) {
+            // order: {
+            //     type: 'ORDER',
+            //     orderId: 'a111f276-95fd-47fc-b77b-709c5ab2e9e1',
+            //     cliOrdId: null,
+            //     symbol: 'PF_LTCUSD',
+            //     side: 'buy',
+            //     quantity: '0.1',
+            //     filled: '0',
+            //     limitPrice: '40',
+            //     reduceOnly: false,
+            //     timestamp: '2026-02-13T12:09:03.738Z',
+            //     lastUpdateTimestamp: '2026-02-13T12:09:03.738Z'
+            // },
+            //     status: 'ENTERED_BOOK',
+            //     updateReason: null,
+            //     error: null
+            //
+            const datetime = this.safeString(orderDictFromFetchOrder, 'timestamp');
+            const innerStatus = this.safeString(order, 'status');
+            return this.safeOrder({
+                'info': order,
+                'id': this.safeString(orderDictFromFetchOrder, 'orderId'),
+                'clientOrderId': this.safeStringN(orderDictFromFetchOrder, ['cliOrdId']),
+                'timestamp': this.parse8601(datetime),
+                'datetime': datetime,
+                'lastTradeTimestamp': undefined,
+                'lastUpdateTimestamp': this.parse8601(this.safeString(orderDictFromFetchOrder, 'lastUpdateTimestamp')),
+                'symbol': this.safeSymbol(this.safeString(orderDictFromFetchOrder, 'symbol'), market),
+                'type': undefined,
+                'timeInForce': undefined,
+                'postOnly': undefined,
+                'reduceOnly': this.safeBool(orderDictFromFetchOrder, 'reduceOnly'),
+                'side': this.safeString(orderDictFromFetchOrder, 'side'),
+                'price': this.safeString(orderDictFromFetchOrder, 'limitPrice'),
+                'triggerPrice': undefined,
+                'amount': this.safeString(orderDictFromFetchOrder, 'quantity'),
+                'cost': undefined,
+                'average': undefined,
+                'filled': this.safeString(orderDictFromFetchOrder, 'filled'),
+                'remaining': undefined,
+                'status': this.parseOrderStatus(innerStatus),
+                'fee': undefined,
+                'fees': undefined,
+                'trades': undefined,
+            });
+        }
         const orderEvents = this.safeValue(order, 'orderEvents', []);
         const errorStatus = this.safeString(order, 'status');
         const orderEventsLength = orderEvents.length;
@@ -2389,7 +2457,7 @@ class krakenfutures extends krakenfutures$1["default"] {
         //         "fundingRate": -0.000000756414717067,
         //         "fundingRatePrediction": 0.000000195218676,
         //         "suspended": false,
-        //         "indexPrice": 0.043392,
+        //         "indexPrice": 0.043391,
         //         "postOnly": false,
         //         "change24h": -0.46
         //     }
@@ -2402,16 +2470,16 @@ class krakenfutures extends krakenfutures$1["default"] {
         let fundingRateResult = Precise["default"].stringDiv(fundingRateString, markPriceString);
         const nextFundingRateString = this.safeString(ticker, 'fundingRatePrediction');
         let nextFundingRateResult = Precise["default"].stringDiv(nextFundingRateString, markPriceString);
-        if (fundingRateResult > '0.25') {
+        if (Precise["default"].stringGt(fundingRateResult, '0.25')) {
             fundingRateResult = '0.25';
         }
-        else if (fundingRateResult > '-0.25') {
+        else if (Precise["default"].stringLt(fundingRateResult, '-0.25')) {
             fundingRateResult = '-0.25';
         }
-        if (nextFundingRateResult > '0.25') {
+        if (Precise["default"].stringGt(nextFundingRateResult, '0.25')) {
             nextFundingRateResult = '0.25';
         }
-        else if (nextFundingRateResult > '-0.25') {
+        else if (Precise["default"].stringLt(nextFundingRateResult, '-0.25')) {
             nextFundingRateResult = '-0.25';
         }
         return {

package/dist/cjs/src/kucoin.js

@@ -128,6 +128,7 @@ class kucoin extends kucoin$1["default"] {
                     'broker': 'https://api-broker.kucoin.com',
                     'earn': 'https://api.kucoin.com',
                     'uta': 'https://api.kucoin.com',
+                    'utaPrivate': 'https://api.kucoin.com',
                 },
                 'www': 'https://www.kucoin.com',
                 'doc': [
@@ -484,17 +485,55 @@ class kucoin extends kucoin$1["default"] {
                     'get': {
                         'market/announcement': 20,
                         'market/currency': 3,
+                        'market/currencies': 3,
                         'market/instrument': 4,
                         'market/ticker': 15,
-                        'market/orderbook': 3,
                         'market/trade': 3,
                         'market/kline': 3,
                         'market/funding-rate': 2,
                         'market/funding-rate-history': 5,
                         'market/cross-config': 25,
+                        'market/collateral-discount-ratio': 10,
+                        'market/index-price': 20,
+                        'market/position-tiers': 20,
+                        'market/open-interest': 10,
                         'server/status': 3,
                     },
                 },
+                'utaPrivate': {
+                    'get': {
+                        'market/orderbook': 3,
+                        'account/balance': 5,
+                        'account/transfer-quota': 20,
+                        'account/mode': 30,
+                        'account/ledger': 2,
+                        'account/interest-history': 15,
+                        'account/deposit/address': 5,
+                        '{accountMode}/account/balance': 5,
+                        '{accountMode}/account/overview': 5,
+                        '{accountMode}/order/detail': 4,
+                        '{accountMode}/order/open-list': 4,
+                        '{accountMode}/order/history': 4,
+                        '{accountMode}/order/execution': 4,
+                        '{accountMode}/position/open-list': 3,
+                        '{accountMode}/position/history': 2,
+                        '{accountMode}/position/tiers': 20,
+                        'sub-account/balance': 5,
+                        'user/fee-rate': 3,
+                        'dcp/query': 2,
+                    },
+                    'post': {
+                        'account/transfer': 4,
+                        'account/mode': 30,
+                        '{accountMode}/account/modify-leverage': 20,
+                        '{accountMode}/order/place': 1,
+                        '{accountMode}/order/place-batch': 4,
+                        '{accountMode}/order/cancel': 1,
+                        '{accountMode}/order/cancel-batch': 4,
+                        'sub-account/canTransferOut': 5,
+                        'dcp/set': 2,
+                    },
+                },
             },
             'timeframes': {
                 '1m': '1min',
@@ -2579,7 +2618,7 @@ class kucoin extends kucoin$1["default"] {
             else {
                 request['tradeType'] = 'FUTURES';
             }
-            response = await this.utaGetMarketOrderbook(this.extend(request, params));
+            response = await this.utaPrivateGetMarketOrderbook(this.extend(request, params));
             //
             //     {
             //         "code": "200000",
@@ -5757,9 +5796,9 @@ class kucoin extends kucoin$1["default"] {
             endpoint = '/api/v1/' + this.implodeParams(path, params);
         }
         let isUtaPrivate = false;
-        if (api === 'uta') {
+        if ((api === 'uta') || (api === 'utaPrivate')) {
             endpoint = '/api/ua/v1/' + this.implodeParams(path, params);
-            if (path === 'market/orderbook') {
+            if (api === 'utaPrivate') {
                 isUtaPrivate = true;
             }
         }

package/dist/cjs/src/mexc.js

@@ -152,8 +152,8 @@ class mexc extends mexc$1["default"] {
                         'private': 'https://www.mexc.com/open/api/v2',
                     },
                     'contract': {
-                        'public': 'https://contract.mexc.com/api/v1/contract',
-                        'private': 'https://contract.mexc.com/api/v1/private',
+                        'public': 'https://api.mexc.com/api/v1/contract',
+                        'private': 'https://api.mexc.com/api/v1/private',
                     },
                     'broker': {
                         'private': 'https://api.mexc.com/api/v3/broker',

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

@@ -778,10 +778,19 @@ class aster extends aster$1["default"] {
         //         "ss": 0
         //     }
         //
+        const e = this.safeString(trade, 'e');
+        const isPublicTrade = (e === 'trade') || (e === 'aggTrade');
         const id = this.safeString2(trade, 't', 'a');
         const timestamp = this.safeInteger(trade, 'T');
         const price = this.safeString2(trade, 'L', 'p');
-        const amount = this.safeString2(trade, 'q', 'l');
+        let amount = undefined;
+        if (isPublicTrade) {
+            amount = this.safeString(trade, 'q');
+        }
+        else {
+            // private trades, amount is in 'l' field, quantity of the last filled trade
+            amount = this.safeString(trade, 'l');
+        }
         let cost = this.safeString(trade, 'Y');
         if (cost === undefined) {
             if ((price !== undefined) && (amount !== undefined)) {
@@ -1711,7 +1720,7 @@ class aster extends aster$1["default"] {
             const myTrades = this.myTrades;
             myTrades.append(trade);
             client.resolve(this.myTrades, messageHash);
-            const messageHashSymbol = messageHash + ':' + symbol;
+            const messageHashSymbol = messageHash + '::' + symbol;
             client.resolve(this.myTrades, messageHashSymbol);
         }
     }

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

@@ -352,7 +352,8 @@ class binance extends binance$1["default"] {
         const symbol = market['symbol'];
         const liquidation = this.parseWsLiquidation(rawLiquidation, market);
         if (this.liquidations === undefined) {
-            this.liquidations = new Cache.ArrayCacheBySymbolBySide();
+            const limit = this.safeInteger(this.options, 'liquidationsLimit', 1000);
+            this.liquidations = new Cache.ArrayCache(limit);
         }
         const cache = this.liquidations;
         cache.append(liquidation);
@@ -562,7 +563,8 @@ class binance extends binance$1["default"] {
         const liquidation = this.parseWsLiquidation(message, market);
         let cache = this.myLiquidations;
         if (cache === undefined) {
-            cache = new Cache.ArrayCacheBySymbolBySide();
+            const limit = this.safeInteger(this.options, 'myLiquidationsLimit', 1000);
+            cache = new Cache.ArrayCache(limit);
         }
         cache.append(liquidation);
         this.myLiquidations = cache;

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

@@ -440,7 +440,8 @@ class bitmex extends bitmex$1["default"] {
         const rawLiquidations = this.safeValue(message, 'data', []);
         const newLiquidations = [];
         if (this.liquidations === undefined) {
-            this.liquidations = new Cache.ArrayCacheBySymbolBySide();
+            const limit = this.safeInteger(this.options, 'liquidationsLimit', 1000);
+            this.liquidations = new Cache.ArrayCache(limit);
         }
         const cache = this.liquidations;
         for (let i = 0; i < rawLiquidations.length; i++) {

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

@@ -1696,7 +1696,8 @@ class bybit extends bybit$1["default"] {
                 const symbol = market['symbol'];
                 const liquidation = this.parseWsLiquidation(rawLiquidation, market);
                 if (this.liquidations === undefined) {
-                    this.liquidations = new Cache.ArrayCacheBySymbolBySide();
+                    const limit = this.safeInteger(this.options, 'liquidationsLimit', 1000);
+                    this.liquidations = new Cache.ArrayCache(limit);
                 }
                 const cache = this.liquidations;
                 cache.append(liquidation);
@@ -1711,7 +1712,8 @@ class bybit extends bybit$1["default"] {
             const symbol = market['symbol'];
             const liquidation = this.parseWsLiquidation(rawLiquidation, market);
             if (this.liquidations === undefined) {
-                this.liquidations = new Cache.ArrayCacheBySymbolBySide();
+                const limit = this.safeInteger(this.options, 'liquidationsLimit', 1000);
+                this.liquidations = new Cache.ArrayCache(limit);
             }
             const cache = this.liquidations;
             cache.append(liquidation);

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

@@ -1524,7 +1524,8 @@ class gate extends gate$1["default"] {
         const rawLiquidations = this.safeList(message, 'result', []);
         const newLiquidations = [];
         if (this.liquidations === undefined) {
-            this.liquidations = new Cache.ArrayCacheBySymbolBySide();
+            const limit = this.safeInteger(this.options, 'liquidationsLimit', 1000);
+            this.liquidations = new Cache.ArrayCache(limit);
         }
         const cache = this.liquidations;
         for (let i = 0; i < rawLiquidations.length; i++) {

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

@@ -758,7 +758,8 @@ class okx extends okx$1["default"] {
             const liquidation = this.parseWsLiquidation(rawLiquidation);
             const symbol = this.safeString(liquidation, 'symbol');
             if (this.liquidations === undefined) {
-                this.liquidations = new Cache.ArrayCacheBySymbolBySide();
+                const limit = this.safeInteger(this.options, 'liquidationsLimit', 1000);
+                this.liquidations = new Cache.ArrayCache(limit);
             }
             const cache = this.liquidations;
             cache.append(liquidation);
@@ -855,7 +856,8 @@ class okx extends okx$1["default"] {
             const liquidation = this.parseWsMyLiquidation(rawLiquidation);
             const symbol = this.safeString(liquidation, 'symbol');
             if (this.liquidations === undefined) {
-                this.liquidations = new Cache.ArrayCacheBySymbolBySide();
+                const limit = this.safeInteger(this.options, 'liquidationsLimit', 1000);
+                this.liquidations = new Cache.ArrayCache(limit);
             }
             const cache = this.liquidations;
             cache.append(liquidation);

package/dist/cjs/src/whitebit.js

@@ -514,6 +514,7 @@ class whitebit extends whitebit$1["default"] {
         const taker = Precise["default"].stringDiv(takerFeeRate, '100');
         const makerFeeRate = this.safeString(market, 'makerFee');
         const maker = Precise["default"].stringDiv(makerFeeRate, '100');
+        const isSpot = !swap;
         return {
             'id': id,
             'symbol': symbol,
@@ -524,7 +525,7 @@ class whitebit extends whitebit$1["default"] {
             'quoteId': quoteId,
             'settleId': settleId,
             'type': type,
-            'spot': !swap,
+            'spot': isSpot,
             'margin': margin,
             'swap': swap,
             'future': false,
@@ -535,7 +536,7 @@ class whitebit extends whitebit$1["default"] {
             'inverse': inverse,
             'taker': this.parseNumber(taker),
             'maker': this.parseNumber(maker),
-            'contractSize': contractSize,
+            'contractSize': isSpot ? undefined : contractSize,
             'expiry': undefined,
             'expiryDatetime': undefined,
             'strike': undefined,
@@ -1798,7 +1799,7 @@ class whitebit extends whitebit$1["default"] {
         //         "time":1737380046
         //     }
         //
-        return this.safeInteger(response, 'time');
+        return this.safeIntegerProduct(response, 'time', 1000);
     }
     /**
      * @method
@@ -2435,7 +2436,7 @@ class whitebit extends whitebit$1["default"] {
             'lastTradeTimestamp': lastTradeTimestamp,
             'timeInForce': undefined,
             'postOnly': undefined,
-            'status': undefined,
+            'status': this.parseOrderStatus(this.safeString(order, 'status')),
             'side': side,
             'price': price,
             'type': orderType,
@@ -2449,6 +2450,15 @@ class whitebit extends whitebit$1["default"] {
             'trades': undefined,
         }, market);
     }
+    parseOrderStatus(status) {
+        const statuses = {
+            'CANCELED': 'canceled',
+            'OPEN': 'open',
+            'PARTIALLY_FILLED': 'open',
+            'FILLED': 'closed',
+        };
+        return this.safeStringLower(statuses, status, status);
+    }
     /**
      * @method
      * @name whitebit#fetchOrderTrades

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 { Int, int, Str, Strings, Num, Bool, IndexType, OrderSide, OrderType, MarketType, SubType, Dict, NullableDict, List, NullableList, Fee, OHLCV, OHLCVC, implicitReturnType, Market, Currency, Dictionary, MinMax, FeeInterface, TradingFeeInterface, MarketInterface, Trade, Order, OrderBook, Ticker, Transaction, Tickers, CurrencyInterface, Balance, BalanceAccount, Account, PartialBalances, Balances, DepositAddress, WithdrawalResponse, FundingRate, FundingRates, Position, BorrowInterest, LeverageTier, LedgerEntry, DepositWithdrawFeeNetwork, DepositWithdrawFee, TransferEntry, CrossBorrowRate, IsolatedBorrowRate, FundingRateHistory, OpenInterest, Liquidation, OrderRequest, CancellationRequest, FundingHistory, MarketMarginModes, MarginMode, Greeks, Conversion, Option, LastPrice, Leverage, MarginModification, Leverages, LastPrices, Currencies, TradingFees, MarginModes, OptionChain, IsolatedBorrowRates, CrossBorrowRates, LeverageTiers, LongShortRatio, OrderBooks, OpenInterests, ConstructorArgs } from './src/base/types.js';
 import { BaseError, ExchangeError, AuthenticationError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, OperationRejected, NoChange, MarginModeAlreadySet, MarketClosed, ManualInteractionNeeded, RestrictedLocation, InsufficientFunds, InvalidAddress, AddressPending, InvalidOrder, OrderNotFound, OrderNotCached, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, ContractUnavailable, NotSupported, InvalidProxySettings, ExchangeClosedByUser, OperationFailed, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, ChecksumError, RequestTimeout, BadResponse, NullResponse, CancelPending, UnsubscribeError } from './src/base/errors.js';
-declare const version = "4.5.35";
+declare const version = "4.5.37";
 import alp from './src/alp.js';
 import alpaca from './src/alpaca.js';
 import apex from './src/apex.js';

package/js/ccxt.js

@@ -38,7 +38,7 @@ import * as errors from './src/base/errors.js';
 import { BaseError, ExchangeError, AuthenticationError, PermissionDenied, AccountNotEnabled, AccountSuspended, ArgumentsRequired, BadRequest, BadSymbol, OperationRejected, NoChange, MarginModeAlreadySet, MarketClosed, ManualInteractionNeeded, RestrictedLocation, InsufficientFunds, InvalidAddress, AddressPending, InvalidOrder, OrderNotFound, OrderNotCached, OrderImmediatelyFillable, OrderNotFillable, DuplicateOrderId, ContractUnavailable, NotSupported, InvalidProxySettings, ExchangeClosedByUser, OperationFailed, NetworkError, DDoSProtection, RateLimitExceeded, ExchangeNotAvailable, OnMaintenance, InvalidNonce, ChecksumError, RequestTimeout, BadResponse, NullResponse, CancelPending, UnsubscribeError } from './src/base/errors.js';
 //-----------------------------------------------------------------------------
 // this is updated by vss.js when building
-const version = '4.5.35';
+const version = '4.5.37';
 Exchange.ccxtVersion = version;
 //-----------------------------------------------------------------------------
 import alp from './src/alp.js';

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

@@ -8,13 +8,18 @@ interface Exchange {
     publicGetTickerPair(params?: {}): Promise<implicitReturnType>;
     publicGetTransactionsPair(params?: {}): Promise<implicitReturnType>;
     publicGetTradingPairsInfo(params?: {}): Promise<implicitReturnType>;
+    publicGetMarkets(params?: {}): Promise<implicitReturnType>;
     publicGetCurrencies(params?: {}): Promise<implicitReturnType>;
     publicGetEurUsd(params?: {}): Promise<implicitReturnType>;
     publicGetTravelRuleVasps(params?: {}): Promise<implicitReturnType>;
+    publicGetFundingRatePair(params?: {}): Promise<implicitReturnType>;
+    publicGetFundingRateHistoryPair(params?: {}): Promise<implicitReturnType>;
     privateGetTravelRuleContacts(params?: {}): Promise<implicitReturnType>;
     privateGetContactsContactUuid(params?: {}): Promise<implicitReturnType>;
     privateGetEarnSubscriptions(params?: {}): Promise<implicitReturnType>;
     privateGetEarnTransactions(params?: {}): Promise<implicitReturnType>;
+    privateGetTradeHistory(params?: {}): Promise<implicitReturnType>;
+    privateGetTradeHistoryPair(params?: {}): Promise<implicitReturnType>;
     privatePostAccountBalances(params?: {}): Promise<implicitReturnType>;
     privatePostAccountBalancesCurrency(params?: {}): Promise<implicitReturnType>;
     privatePostBalance(params?: {}): Promise<implicitReturnType>;
@@ -27,6 +32,7 @@ interface Exchange {
     privatePostOpenOrder(params?: {}): Promise<implicitReturnType>;
     privatePostOpenOrdersAll(params?: {}): Promise<implicitReturnType>;
     privatePostOpenOrdersPair(params?: {}): Promise<implicitReturnType>;
+    privatePostReplaceOrder(params?: {}): Promise<implicitReturnType>;
     privatePostOrderStatus(params?: {}): Promise<implicitReturnType>;
     privatePostCancelOrder(params?: {}): Promise<implicitReturnType>;
     privatePostCancelAllOrders(params?: {}): Promise<implicitReturnType>;
@@ -52,6 +58,8 @@ interface Exchange {
     privatePostLiquidationAddressInfo(params?: {}): Promise<implicitReturnType>;
     privatePostBtcUnconfirmed(params?: {}): Promise<implicitReturnType>;
     privatePostWebsocketsToken(params?: {}): Promise<implicitReturnType>;
+    privatePostRevokeAllApiKeys(params?: {}): Promise<implicitReturnType>;
+    privatePostGetMaxOrderAmount(params?: {}): Promise<implicitReturnType>;
     privatePostBtcWithdrawal(params?: {}): Promise<implicitReturnType>;
     privatePostBtcAddress(params?: {}): Promise<implicitReturnType>;
     privatePostRippleWithdrawal(params?: {}): Promise<implicitReturnType>;

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

@@ -310,6 +310,7 @@ interface Exchange {
     privatePostV5AccountBorrow(params?: {}): Promise<implicitReturnType>;
     privatePostV5AccountRepay(params?: {}): Promise<implicitReturnType>;
     privatePostV5AccountNoConvertRepay(params?: {}): Promise<implicitReturnType>;
+    privatePostV5AccountSetLimitPxAction(params?: {}): Promise<implicitReturnType>;
     privatePostV5AssetExchangeQuoteApply(params?: {}): Promise<implicitReturnType>;
     privatePostV5AssetExchangeConvertExecute(params?: {}): Promise<implicitReturnType>;
     privatePostV5AssetTransferInterTransfer(params?: {}): Promise<implicitReturnType>;

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

@@ -259,15 +259,47 @@ interface Exchange {
     earnDeleteEarnOrders(params?: {}): Promise<implicitReturnType>;
     utaGetMarketAnnouncement(params?: {}): Promise<implicitReturnType>;
     utaGetMarketCurrency(params?: {}): Promise<implicitReturnType>;
+    utaGetMarketCurrencies(params?: {}): Promise<implicitReturnType>;
     utaGetMarketInstrument(params?: {}): Promise<implicitReturnType>;
     utaGetMarketTicker(params?: {}): Promise<implicitReturnType>;
-    utaGetMarketOrderbook(params?: {}): Promise<implicitReturnType>;
     utaGetMarketTrade(params?: {}): Promise<implicitReturnType>;
     utaGetMarketKline(params?: {}): Promise<implicitReturnType>;
     utaGetMarketFundingRate(params?: {}): Promise<implicitReturnType>;
     utaGetMarketFundingRateHistory(params?: {}): Promise<implicitReturnType>;
     utaGetMarketCrossConfig(params?: {}): Promise<implicitReturnType>;
+    utaGetMarketCollateralDiscountRatio(params?: {}): Promise<implicitReturnType>;
+    utaGetMarketIndexPrice(params?: {}): Promise<implicitReturnType>;
+    utaGetMarketPositionTiers(params?: {}): Promise<implicitReturnType>;
+    utaGetMarketOpenInterest(params?: {}): Promise<implicitReturnType>;
     utaGetServerStatus(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetMarketOrderbook(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountBalance(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountTransferQuota(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountMode(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountLedger(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountInterestHistory(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountDepositAddress(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountModeAccountBalance(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountModeAccountOverview(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountModeOrderDetail(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountModeOrderOpenList(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountModeOrderHistory(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountModeOrderExecution(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountModePositionOpenList(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountModePositionHistory(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountModePositionTiers(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetSubAccountBalance(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetUserFeeRate(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetDcpQuery(params?: {}): Promise<implicitReturnType>;
+    utaPrivatePostAccountTransfer(params?: {}): Promise<implicitReturnType>;
+    utaPrivatePostAccountMode(params?: {}): Promise<implicitReturnType>;
+    utaPrivatePostAccountModeAccountModifyLeverage(params?: {}): Promise<implicitReturnType>;
+    utaPrivatePostAccountModeOrderPlace(params?: {}): Promise<implicitReturnType>;
+    utaPrivatePostAccountModeOrderPlaceBatch(params?: {}): Promise<implicitReturnType>;
+    utaPrivatePostAccountModeOrderCancel(params?: {}): Promise<implicitReturnType>;
+    utaPrivatePostAccountModeOrderCancelBatch(params?: {}): Promise<implicitReturnType>;
+    utaPrivatePostSubAccountCanTransferOut(params?: {}): Promise<implicitReturnType>;
+    utaPrivatePostDcpSet(params?: {}): Promise<implicitReturnType>;
 }
 declare abstract class Exchange extends _Exchange {
 }

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

@@ -287,15 +287,47 @@ interface kucoin {
     earnDeleteEarnOrders(params?: {}): Promise<implicitReturnType>;
     utaGetMarketAnnouncement(params?: {}): Promise<implicitReturnType>;
     utaGetMarketCurrency(params?: {}): Promise<implicitReturnType>;
+    utaGetMarketCurrencies(params?: {}): Promise<implicitReturnType>;
     utaGetMarketInstrument(params?: {}): Promise<implicitReturnType>;
     utaGetMarketTicker(params?: {}): Promise<implicitReturnType>;
-    utaGetMarketOrderbook(params?: {}): Promise<implicitReturnType>;
     utaGetMarketTrade(params?: {}): Promise<implicitReturnType>;
     utaGetMarketKline(params?: {}): Promise<implicitReturnType>;
     utaGetMarketFundingRate(params?: {}): Promise<implicitReturnType>;
     utaGetMarketFundingRateHistory(params?: {}): Promise<implicitReturnType>;
     utaGetMarketCrossConfig(params?: {}): Promise<implicitReturnType>;
+    utaGetMarketCollateralDiscountRatio(params?: {}): Promise<implicitReturnType>;
+    utaGetMarketIndexPrice(params?: {}): Promise<implicitReturnType>;
+    utaGetMarketPositionTiers(params?: {}): Promise<implicitReturnType>;
+    utaGetMarketOpenInterest(params?: {}): Promise<implicitReturnType>;
     utaGetServerStatus(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetMarketOrderbook(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountBalance(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountTransferQuota(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountMode(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountLedger(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountInterestHistory(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountDepositAddress(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountModeAccountBalance(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountModeAccountOverview(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountModeOrderDetail(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountModeOrderOpenList(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountModeOrderHistory(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountModeOrderExecution(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountModePositionOpenList(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountModePositionHistory(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetAccountModePositionTiers(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetSubAccountBalance(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetUserFeeRate(params?: {}): Promise<implicitReturnType>;
+    utaPrivateGetDcpQuery(params?: {}): Promise<implicitReturnType>;
+    utaPrivatePostAccountTransfer(params?: {}): Promise<implicitReturnType>;
+    utaPrivatePostAccountMode(params?: {}): Promise<implicitReturnType>;
+    utaPrivatePostAccountModeAccountModifyLeverage(params?: {}): Promise<implicitReturnType>;
+    utaPrivatePostAccountModeOrderPlace(params?: {}): Promise<implicitReturnType>;
+    utaPrivatePostAccountModeOrderPlaceBatch(params?: {}): Promise<implicitReturnType>;
+    utaPrivatePostAccountModeOrderCancel(params?: {}): Promise<implicitReturnType>;
+    utaPrivatePostAccountModeOrderCancelBatch(params?: {}): Promise<implicitReturnType>;
+    utaPrivatePostSubAccountCanTransferOut(params?: {}): Promise<implicitReturnType>;
+    utaPrivatePostDcpSet(params?: {}): Promise<implicitReturnType>;
 }
 declare abstract class kucoin extends _kucoin {
 }

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

@@ -766,6 +766,7 @@ export default class Exchange {
     fetchOrderStatus(id: string, symbol?: Str, params?: {}): Promise<string>;
     fetchUnifiedOrder(order: any, params?: {}): Promise<Order>;
     createOrder(symbol: string, type: OrderType, side: OrderSide, amount: number, price?: Num, params?: {}): Promise<Order>;
+    createTwapOrder(symbol: string, side: OrderSide, amount: number, duration: number, params?: {}): Promise<Order>;
     createConvertTrade(id: string, fromCode: string, toCode: string, amount?: Num, params?: {}): Promise<Conversion>;
     fetchConvertTrade(id: string, code?: Str, params?: {}): Promise<Conversion>;
     fetchConvertTradeHistory(code?: Str, since?: Int, limit?: Int, params?: {}): Promise<Conversion[]>;

package/js/src/base/Exchange.js

@@ -5491,6 +5491,9 @@ export default class Exchange {
     async createOrder(symbol, type, side, amount, price = undefined, params = {}) {
         throw new NotSupported(this.id + ' createOrder() is not supported yet');
     }
+    async createTwapOrder(symbol, side, amount, duration, params = {}) {
+        throw new NotSupported(this.id + ' createTwapOrder() is not supported yet');
+    }
     async createConvertTrade(id, fromCode, toCode, amount = undefined, params = {}) {
         throw new NotSupported(this.id + ' createConvertTrade() is not supported yet');
     }

package/js/src/bitmex.js

@@ -1881,10 +1881,12 @@ export default class bitmex extends Exchange {
         else {
             filled = cumQty;
         }
-        const execInst = this.safeString(order, 'execInst');
+        const execInst = this.safeString(order, 'execInst', '');
         let postOnly = undefined;
-        if (execInst !== undefined) {
-            postOnly = (execInst === 'ParticipateDoNotInitiate');
+        let reduceOnly = undefined;
+        if (execInst.length > 0) {
+            postOnly = (execInst.indexOf('ParticipateDoNotInitiate') >= 0);
+            reduceOnly = ((execInst.indexOf('ReduceOnly') >= 0) || (execInst.indexOf('Close') >= 0));
         }
         const timestamp = this.parse8601(this.safeString(order, 'timestamp'));
         const triggerPrice = this.safeNumber(order, 'stopPx');
@@ -1900,6 +1902,7 @@ export default class bitmex extends Exchange {
             'type': this.safeStringLower(order, 'ordType'),
             'timeInForce': this.parseTimeInForce(this.safeString(order, 'timeInForce')),
             'postOnly': postOnly,
+            'reduceOnly': reduceOnly,
             'side': this.safeStringLower(order, 'side'),
             'price': this.safeString(order, 'price'),
             'triggerPrice': triggerPrice,
@@ -2008,6 +2011,8 @@ export default class bitmex extends Exchange {
                 throw new InvalidOrder(this.id + ' createOrder() does not support reduceOnly for ' + market['type'] + ' orders, reduceOnly orders are supported for swap and future markets only');
             }
         }
+        const postOnly = this.safeBool(params, 'postOnly');
+        params = this.omit(params, ['reduceOnly', 'postOnly']);
         const brokerId = this.safeString(this.options, 'brokerId', 'CCXT');
         const qty = this.parseToInt(this.amountToPrecision(symbol, amount));
         const request = {
@@ -2017,6 +2022,17 @@ export default class bitmex extends Exchange {
             'ordType': orderType,
             'text': brokerId,
         };
+        const execInstructions = [];
+        if (reduceOnly === true) {
+            execInstructions.push('ReduceOnly');
+        }
+        if (postOnly === true) {
+            execInstructions.push('ParticipateDoNotInitiate');
+        }
+        const execInstLength = execInstructions.length;
+        if (execInstLength > 0) {
+            request['execInst'] = execInstructions.join(',');
+        }
         // support for unified trigger format
         const triggerPrice = this.safeNumberN(params, ['triggerPrice', 'stopPx', 'stopPrice']);
         let trailingAmount = this.safeString2(params, 'trailingAmount', 'pegOffsetValue');