ccxt 4.5.45 → 4.5.47

package/js/src/kucoin.js

@@ -42,10 +42,13 @@ export default class kucoin extends Exchange {
                 'createMarketSellOrderWithCost': true,
                 'createOrder': true,
                 'createOrders': true,
+                'createOrderWithTakeProfitAndStopLoss': true,
                 'createPostOnlyOrder': true,
                 'createStopLimitOrder': true,
+                'createStopLossOrder': true,
                 'createStopMarketOrder': true,
                 'createStopOrder': true,
+                'createTakeProfitOrder': true,
                 'createTriggerOrder': true,
                 'editOrder': true,
                 'fetchAccounts': true,
@@ -84,8 +87,9 @@ export default class kucoin extends Exchange {
                 'fetchMarkPrices': true,
                 'fetchMyTrades': true,
                 'fetchOHLCV': true,
-                'fetchOpenInterest': false,
-                'fetchOpenInterestHistory': false,
+                'fetchOpenInterest': true,
+                'fetchOpenInterestHistory': true,
+                'fetchOpenInterests': true,
                 'fetchOpenOrders': true,
                 'fetchOrder': true,
                 'fetchOrderBook': true,
@@ -94,7 +98,7 @@ export default class kucoin extends Exchange {
                 'fetchOrderTrades': true,
                 'fetchPosition': true,
                 'fetchPositionADLRank': true,
-                'fetchPositionHistory': false,
+                'fetchPositionHistory': true,
                 'fetchPositionMode': true,
                 'fetchPositions': true,
                 'fetchPositionsADLRank': true,
@@ -186,6 +190,7 @@ export default class kucoin extends Exchange {
                     'get': {
                         // account
                         'user-info': 20,
+                        'user/api-key': 20,
                         'accounts': 5,
                         'accounts/{accountId}': 5,
                         'accounts/ledgers': 2,
@@ -561,6 +566,7 @@ export default class kucoin extends Exchange {
                         '{accountMode}/order/execution': 8,
                         '{accountMode}/position/open-list': 6,
                         '{accountMode}/position/history': 4,
+                        'position/history': 4,
                         '{accountMode}/position/tiers': 40,
                         'sub-account/balance': 10,
                         'user/fee-rate': 6,
@@ -625,6 +631,7 @@ export default class kucoin extends Exchange {
                     '503': ExchangeNotAvailable,
                     '101030': PermissionDenied,
                     '103000': InvalidOrder,
+                    '112010': PermissionDenied,
                     '130101': BadRequest,
                     '130102': ExchangeError,
                     '130103': OrderNotFound,
@@ -703,7 +710,7 @@ export default class kucoin extends Exchange {
                     '400006': AuthenticationError,
                     '400007': AuthenticationError,
                     '400008': NotSupported,
-                    '400100': InsufficientFunds,
+                    '400100': BadRequest,
                     '400200': InvalidOrder,
                     '400330': InvalidOrder,
                     '400350': InvalidOrder,
@@ -735,6 +742,7 @@ export default class kucoin extends Exchange {
                     '330008': InsufficientFunds, // {"msg":"Your current margin and leverage have reached the maximum open limit. Please increase your margin or raise your leverage to open larger positions.","code":"330008"}
                 },
                 'broad': {
+                    'pageSize should not greater than 500': BadRequest,
                     'Exceeded the access frequency': RateLimitExceeded,
                     'require more permission': PermissionDenied,
                     // futures errors
@@ -873,15 +881,14 @@ export default class kucoin extends Exchange {
             },
             'options': {
                 'hf': undefined,
+                'uta': undefined,
                 'version': 'v1',
                 'symbolSeparator': '-',
                 'fetchMyTradesMethod': 'private_get_fills',
                 'timeDifference': 0,
                 'adjustForTimeDifference': false,
                 'fetchCurrencies': {
-                    'webApiEnable': true,
-                    'webApiRetries': 1,
-                    'webApiMuteFailure': true,
+                    'brokenCurrencies': ['00', 'OPEN_ERROR', 'HUF', 'BDT'], // skip buggy entries: https://t.me/KuCoin_API/217798
                 },
                 'fetchMarkets': {
                     'types': ['spot', 'swap', 'future', 'contract'],
@@ -896,6 +903,13 @@ export default class kucoin extends Exchange {
                 'fetchBalance': {
                     'code': 'USDT', // for contract endpoint
                 },
+                'timeInForce': {
+                    'IOC': 'IOC',
+                    'FOK': 'FOK',
+                    'PO': 'PO',
+                    'GTD': 'GTT',
+                    'RPI': 'RPI',
+                },
                 'timeframes': {
                     'swap': {
                         '1m': 1,
@@ -1059,12 +1073,32 @@ export default class kucoin extends Exchange {
                     'mining': 'pool',
                     'hf': 'trade_hf',
                     'contract': 'contract',
+                    'uta': 'unified',
+                    'unified': 'unified',
+                },
+                'utaAccountsByType': {
+                    'trade': 'SPOT',
+                    'spot': 'SPOT',
+                    'margin': 'CROSS',
+                    'cross': 'CROSS',
+                    'isolated': 'ISOLATED',
+                    'main': 'FUNDING',
+                    'funding': 'FUNDING',
+                    'future': 'FUTURES',
+                    'swap': 'FUTURES',
+                    'contract': 'FUTURES',
+                    'uta': 'unified',
+                    'unified': 'unified',
                 },
                 'networks': {
+                    'BTC': 'btc',
                     'BRC20': 'btc',
                     'BTCNATIVESEGWIT': 'bech32',
+                    'ETH': 'eth',
                     'ERC20': 'eth',
+                    'TRX': 'trx',
                     'TRC20': 'trx',
+                    'HECO': 'heco',
                     'HRC20': 'heco',
                     'MATIC': 'matic',
                     'KCC': 'kcc',
@@ -1079,6 +1113,7 @@ export default class kucoin extends Exchange {
                     'TLOS': 'tlos',
                     'CFX': 'cfx',
                     'ACA': 'aca',
+                    'OP': 'optimism',
                     'OPTIMISM': 'optimism',
                     'ONT': 'ont',
                     'GLMR': 'glmr',
@@ -1269,6 +1304,14 @@ export default class kucoin extends Exchange {
                     // 'KLEVER': 'klv',
                     // undetermined: xns(insolar), rhoc, luk (luniverse), kts (klimatas), bchn (bitcoin cash node), god (shallow entry), lit (litmus),
                 },
+                'networksById': {
+                    'btc': 'BTC',
+                    'trx': 'TRC20',
+                    'eth': 'ERC20',
+                    'heco': 'HRC20',
+                    'optimism': 'OP',
+                    'op': 'OP',
+                },
                 'marginModes': {
                     'cross': 'MARGIN_TRADE',
                     'isolated': 'MARGIN_ISOLATED_TRADE',
@@ -1352,7 +1395,11 @@ export default class kucoin extends Exchange {
                         'stopLossPrice': true,
                         'takeProfitPrice': true,
                         'attachedStopLossTakeProfit': {
-                            'triggerPriceType': undefined,
+                            'triggerPriceType': {
+                                'last': true,
+                                'mark': true,
+                                'index': true,
+                            },
                             'price': true,
                         },
                         'timeInForce': {
@@ -1478,8 +1525,8 @@ export default class kucoin extends Exchange {
      * @returns {object} a [status structure]{@link https://docs.ccxt.com/?id=exchange-status-structure}
      */
     async fetchStatus(params = {}) {
-        let uta = undefined;
-        [uta, params] = this.handleOptionAndParams(params, 'fetchStatus', 'uta', false);
+        let uta = false;
+        [uta, params] = this.handleOptionAndParams(params, 'fetchStatus', 'uta', uta);
         let type = undefined;
         [type, params] = this.handleMarketTypeAndParams('fetchStatus', undefined, params);
         let response = undefined;
@@ -1550,8 +1597,8 @@ export default class kucoin extends Exchange {
     async fetchMarkets(params = {}) {
         let fetchTickersFees = undefined;
         [fetchTickersFees, params] = this.handleOptionAndParams(params, 'fetchMarkets', 'fetchTickersFees', true);
-        let uta = undefined;
-        [uta, params] = this.handleOptionAndParams(params, 'fetchMarkets', 'uta', false);
+        let uta = false;
+        [uta, params] = this.handleOptionAndParams(params, 'fetchMarkets', 'uta', uta);
         if (uta) {
             return await this.fetchUTAMarkets(params);
         }
@@ -2087,7 +2134,7 @@ export default class kucoin extends Exchange {
                 'strike': undefined,
                 'optionType': undefined,
                 'precision': {
-                    'amount': this.safeNumber(market, 'lotSize'),
+                    'amount': this.safeNumber2(market, 'lotSize', 'baseOrderStep'),
                     'price': this.safeNumber(market, 'tickSize'),
                 },
                 'limits': {
@@ -2159,9 +2206,13 @@ export default class kucoin extends Exchange {
      */
     async fetchCurrencies(params = {}) {
         let uta = false;
+        if (this.checkRequiredCredentials(false)) {
+            uta = await this.isUTAEnabled();
+        }
         [uta, params] = this.handleOptionAndParams(params, 'fetchCurrencies', 'uta', uta);
         let response = undefined;
         if (uta) {
+            response = await this.utaGetAssetCurrencies(params);
             //
             //     {
             //         "code": "200000",
@@ -2196,7 +2247,6 @@ export default class kucoin extends Exchange {
             //         ]
             //     }
             //
-            response = await this.utaGetAssetCurrencies(params);
         }
         else {
             //
@@ -2239,64 +2289,61 @@ export default class kucoin extends Exchange {
             response = await this.publicGetCurrencies(params);
         }
         const currenciesData = this.safeList(response, 'data', []);
-        const brokenCurrencies = this.safeList(this.options, 'brokenCurrencies', ['00', 'OPEN_ERROR', 'HUF', 'BDT']);
-        const result = {};
-        for (let i = 0; i < currenciesData.length; i++) {
-            const entry = currenciesData[i];
-            const id = this.safeString(entry, 'currency');
-            if (this.inArray(id, brokenCurrencies)) {
-                continue; // skip buggy entries: https://t.me/KuCoin_API/217798
-            }
-            const code = this.safeCurrencyCode(id);
-            const networks = {};
-            const chains = this.safeList2(entry, 'chains', 'items', []);
-            const chainsLength = chains.length;
-            for (let j = 0; j < chainsLength; j++) {
-                const chain = chains[j];
-                const chainId = this.safeString(chain, 'chainId');
-                const networkCode = this.networkIdToCode(chainId, code);
-                networks[networkCode] = {
-                    'info': chain,
-                    'id': chainId,
-                    'name': this.safeString(chain, 'chainName'),
-                    'code': networkCode,
-                    'active': undefined,
-                    'fee': this.safeNumber2(chain, 'withdrawalMinFee', 'minWithdrawFee'),
-                    'deposit': this.safeBool(chain, 'isDepositEnabled'),
-                    'withdraw': this.safeBool(chain, 'isWithdrawEnabled'),
-                    'precision': this.parseNumber(this.parsePrecision(this.safeString(chain, 'withdrawPrecision'))),
-                    'limits': {
-                        'withdraw': {
-                            'min': this.safeNumber2(chain, 'withdrawalMinSize', 'minWithdrawSize'),
-                            'max': this.safeNumber2(chain, 'maxWithdraw', 'maxWithdrawSize'),
-                        },
-                        'deposit': {
-                            'min': this.safeNumber2(chain, 'depositMinSize', 'minDepositSize'),
-                            'max': this.safeNumber2(chain, 'maxDeposit', 'maxDepositSize'),
-                        },
-                    },
-                };
-            }
-            // kucoin has determined 'fiat' currencies with below logic
-            const rawPrecision = this.safeString(entry, 'precision');
-            const precision = this.parseNumber(this.parsePrecision(rawPrecision));
-            const isFiat = chainsLength === 0;
-            result[code] = this.safeCurrencyStructure({
-                'id': id,
-                'name': this.safeString(entry, 'fullName'),
-                'code': code,
-                'type': isFiat ? 'fiat' : 'crypto',
-                'precision': precision,
-                'info': entry,
-                'networks': networks,
-                'deposit': undefined,
-                'withdraw': undefined,
+        const brokenCurrencies = this.handleOption('fetchCurrencies', 'brokenCurrencies', []);
+        const filteredCurrencies = this.filterOutByArray(currenciesData, 'currency', brokenCurrencies); // remove broken entries
+        return this.parseCurrencies(filteredCurrencies);
+    }
+    parseCurrency(currency) {
+        const entry = currency;
+        const id = this.safeString(entry, 'currency');
+        const code = this.safeCurrencyCode(id);
+        const networks = {};
+        const chains = this.safeList2(entry, 'chains', 'items', []);
+        const chainsLength = chains.length;
+        for (let j = 0; j < chainsLength; j++) {
+            const chain = chains[j];
+            const chainId = this.safeString(chain, 'chainId');
+            const networkCode = this.networkIdToCode(chainId, code);
+            networks[networkCode] = {
+                'info': chain,
+                'id': chainId,
+                'name': this.safeString(chain, 'chainName'),
+                'code': networkCode,
                 'active': undefined,
-                'fee': undefined,
-                'limits': undefined,
-            });
+                'fee': this.safeNumber2(chain, 'withdrawalMinFee', 'minWithdrawFee'),
+                'deposit': this.safeBool(chain, 'isDepositEnabled'),
+                'withdraw': this.safeBool(chain, 'isWithdrawEnabled'),
+                'precision': this.parseNumber(this.parsePrecision(this.safeString(chain, 'withdrawPrecision'))),
+                'limits': {
+                    'withdraw': {
+                        'min': this.safeNumber2(chain, 'withdrawalMinSize', 'minWithdrawSize'),
+                        'max': this.safeNumber2(chain, 'maxWithdraw', 'maxWithdrawSize'),
+                    },
+                    'deposit': {
+                        'min': this.safeNumber2(chain, 'depositMinSize', 'minDepositSize'),
+                        'max': this.safeNumber2(chain, 'maxDeposit', 'maxDepositSize'),
+                    },
+                },
+            };
         }
-        return result;
+        // kucoin has determined 'fiat' currencies with below logic
+        const rawPrecision = this.safeString(entry, 'precision');
+        const precision = this.parseNumber(this.parsePrecision(rawPrecision));
+        const isFiat = chainsLength === 0;
+        return this.safeCurrencyStructure({
+            'id': id,
+            'name': this.safeString(entry, 'fullName'),
+            'code': code,
+            'type': isFiat ? 'fiat' : 'crypto',
+            'precision': precision,
+            'info': entry,
+            'networks': networks,
+            'deposit': undefined,
+            'withdraw': undefined,
+            'active': undefined,
+            'fee': undefined,
+            'limits': undefined,
+        });
     }
     /**
      * @method
@@ -2304,41 +2351,68 @@ export default class kucoin extends Exchange {
      * @description fetch all the accounts associated with a profile
      * @see https://www.kucoin.com/docs-new/rest/account-info/account-funding/get-account-list-spot
      * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {boolean} [params.uta] set to true for the unified trading account (uta), defaults to false
      * @returns {object} a dictionary of [account structures]{@link https://docs.ccxt.com/?id=account-structure} indexed by the account type
      */
     async fetchAccounts(params = {}) {
-        const response = await this.privateGetAccounts(params);
-        //
-        //     {
-        //         "code": "200000",
-        //         "data": [
-        //             {
-        //                 "balance": "0.00009788",
-        //                 "available": "0.00009788",
-        //                 "holds": "0",
-        //                 "currency": "BTC",
-        //                 "id": "5c6a4fd399a1d81c4f9cc4d0",
-        //                 "type": "trade"
-        //             },
-        //             {
-        //                 "balance": "0.00000001",
-        //                 "available": "0.00000001",
-        //                 "holds": "0",
-        //                 "currency": "ETH",
-        //                 "id": "5c6a49ec99a1d819392e8e9f",
-        //                 "type": "trade"
-        //             }
-        //         ]
-        //     }
-        //
-        const data = this.safeList(response, 'data', []);
+        let uta = await this.isUTAEnabled();
+        [uta, params] = this.handleOptionAndParams(params, 'fetchAccounts', 'uta', uta);
+        let response = undefined;
+        let data = [];
+        if (uta) {
+            response = await this.utaPrivateGetAccountModeAccountOverview(this.extend(params, { 'accountMode': 'unified' }));
+            //
+            //     {
+            //         "code": "200000",
+            //         "data": {
+            //             "accountType": "UNIFIED",
+            //             "riskRatio": "0.0000000000",
+            //             "equity": "30.0000000000",
+            //             "liability": "0.0000000000",
+            //             "availableMargin": "30.0000000000",
+            //             "adjustedEquity": "30.0000000000",
+            //             "im": "0.0000000000",
+            //             "mm": "0.0000000000"
+            //         }
+            //     }
+            //
+            const dataDict = this.safeDict(response, 'data', {});
+            data = [dataDict];
+        }
+        else {
+            //
+            //     {
+            //         "code": "200000",
+            //         "data": [
+            //             {
+            //                 "balance": "0.00009788",
+            //                 "available": "0.00009788",
+            //                 "holds": "0",
+            //                 "currency": "BTC",
+            //                 "id": "5c6a4fd399a1d81c4f9cc4d0",
+            //                 "type": "trade"
+            //             },
+            //             {
+            //                 "balance": "0.00000001",
+            //                 "available": "0.00000001",
+            //                 "holds": "0",
+            //                 "currency": "ETH",
+            //                 "id": "5c6a49ec99a1d819392e8e9f",
+            //                 "type": "trade"
+            //             }
+            //         ]
+            //     }
+            //
+            response = await this.privateGetAccounts(params);
+            data = this.safeList(response, 'data', []);
+        }
         const result = [];
         for (let i = 0; i < data.length; i++) {
             const account = data[i];
             const accountId = this.safeString(account, 'id');
             const currencyId = this.safeString(account, 'currency');
             const code = this.safeCurrencyCode(currencyId);
-            const type = this.safeString(account, 'type'); // main or trade
+            const type = this.safeStringLower2(account, 'type', 'accountType'); // main or trade or unified
             result.push({
                 'id': accountId,
                 'type': type,
@@ -2367,7 +2441,7 @@ export default class kucoin extends Exchange {
         let networkCode = undefined;
         [networkCode, params] = this.handleNetworkCodeAndParams(params);
         if (networkCode !== undefined) {
-            request['chain'] = this.networkCodeToId(networkCode).toLowerCase();
+            request['chain'] = this.networkCodeToId(networkCode, currency['code']).toLowerCase();
         }
         const response = await this.privateGetWithdrawalsQuotas(this.extend(request, params));
         const data = this.safeDict(response, 'data', {});
@@ -2398,7 +2472,7 @@ export default class kucoin extends Exchange {
         let networkCode = undefined;
         [networkCode, params] = this.handleNetworkCodeAndParams(params);
         if (networkCode !== undefined) {
-            request['chain'] = this.networkCodeToId(networkCode).toLowerCase();
+            request['chain'] = this.networkCodeToId(networkCode, currency['code']).toLowerCase();
         }
         const response = await this.privateGetWithdrawalsQuotas(this.extend(request, params));
         //
@@ -2455,7 +2529,8 @@ export default class kucoin extends Exchange {
             const chains = this.safeList(fee, 'chains', []);
             for (let i = 0; i < chains.length; i++) {
                 const chain = chains[i];
-                const networkCodeNew = this.networkIdToCode(this.safeString(chain, 'chainId'), this.safeString(currency, 'code'));
+                const chainId = this.safeString(chain, 'chainId');
+                const networkCodeNew = this.networkIdToCode(chainId, this.safeString(currency, 'code'));
                 resultNew['networks'][networkCodeNew] = {
                     'withdraw': {
                         'fee': this.safeNumber2(chain, 'withdrawalMinFee', 'withdrawMinFee'),
@@ -2483,7 +2558,9 @@ export default class kucoin extends Exchange {
             'networks': {},
         };
         const networkId = this.safeString(fee, 'chain');
-        const networkCode = this.networkIdToCode(networkId, this.safeString(currency, 'code'));
+        const currencyId = this.safeString(fee, 'currency');
+        currency = this.safeCurrency(currencyId, currency);
+        const networkCode = this.networkIdToCode(networkId, currency['code']);
         result['networks'][networkCode] = {
             'withdraw': minWithdrawFee,
             'deposit': {
@@ -2768,8 +2845,8 @@ export default class kucoin extends Exchange {
         await this.loadMarkets();
         const request = {};
         symbols = this.marketSymbols(symbols, undefined, true, true);
-        let uta = undefined;
-        [uta, params] = this.handleOptionAndParams(params, 'fetchTickers', 'uta', false);
+        let uta = false;
+        [uta, params] = this.handleOptionAndParams(params, 'fetchTickers', 'uta', uta);
         const tradeType = this.safeString(params, 'tradeType');
         let firstMarket = undefined;
         if (symbols !== undefined) {
@@ -2969,8 +3046,8 @@ export default class kucoin extends Exchange {
         const request = {
             'symbol': market['id'],
         };
-        let uta = undefined;
-        [uta, params] = this.handleOptionAndParams(params, 'fetchTicker', 'uta', false);
+        let uta = false;
+        [uta, params] = this.handleOptionAndParams(params, 'fetchTicker', 'uta', uta);
         let response = undefined;
         let result = undefined;
         let type = undefined;
@@ -3143,8 +3220,8 @@ export default class kucoin extends Exchange {
     async fetchOHLCV(symbol, timeframe = '1m', since = undefined, limit = undefined, params = {}) {
         await this.loadMarkets();
         const market = this.market(symbol);
-        let uta = undefined;
-        [uta, params] = this.handleOptionAndParams(params, 'fetchOHLCV', 'uta', false);
+        let uta = false;
+        [uta, params] = this.handleOptionAndParams(params, 'fetchOHLCV', 'uta', uta);
         if (uta) {
             return await this.fetchUTAOHLCV(symbol, timeframe, since, limit, params);
         }
@@ -3365,7 +3442,7 @@ export default class kucoin extends Exchange {
         let networkCode = undefined;
         [networkCode, params] = this.handleNetworkCodeAndParams(params);
         if (networkCode !== undefined) {
-            request['chain'] = this.networkCodeToId(networkCode); // docs mention "chain-name", but seems "chain-id" is used, like in "fetchDepositAddress"
+            request['chain'] = this.networkCodeToId(networkCode, currency['code']); // docs mention "chain-name", but seems "chain-id" is used, like in "fetchDepositAddress"
         }
         const response = await this.privatePostDepositAddressCreate(this.extend(request, params));
         // {"code":"260000","msg":"Deposit address already exists."}
@@ -3391,10 +3468,12 @@ export default class kucoin extends Exchange {
      * @name kucoin#fetchDepositAddress
      * @description fetch the deposit address for a currency associated with this account
      * @see https://www.kucoin.com/docs-new/rest/account-info/deposit/get-deposit-address-v3/en
+     * @see https://www.kucoin.com/docs-new/rest/ua/get-deposit-address
      * @param {string} code unified currency code
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @param {string} [params.network] the blockchain network name
-     * @param {string} [params.accountType] 'main' or 'contract' (default is 'main')
+     * @param {string} [params.accountType] 'main', 'contract' or 'uta' (default is 'main')
+     * @param {boolean} [params.uta] set to true for the unified trading account (uta) endpoint, defaults to false
      * @returns {object} an [address structure]{@link https://docs.ccxt.com/?id=address-structure}
      */
     async fetchDepositAddress(code, params = {}) {
@@ -3403,9 +3482,14 @@ export default class kucoin extends Exchange {
         [accountType, params] = this.handleOptionAndParams(params, 'fetchDepositAddress', 'accountType', accountType);
         const accountsByType = this.safeDict(this.options, 'accountsByType', {});
         accountType = this.safeString(accountsByType, accountType, accountType);
+        let uta = await this.isUTAEnabled();
+        [uta, params] = this.handleOptionAndParams(params, 'fetchDepositAddress', 'uta', uta);
         if (accountType === 'contract') {
             return await this.fetchContractDepositAddress(code, params);
         }
+        else if (uta || (accountType === 'uta') || (accountType === 'unified')) {
+            return await super.fetchDepositAddress(code, this.extend(params, { 'uta': true }));
+        }
         const currency = this.currency(code);
         const request = {
             'currency': currency['id'],
@@ -3416,7 +3500,7 @@ export default class kucoin extends Exchange {
         let networkCode = undefined;
         [networkCode, params] = this.handleNetworkCodeAndParams(params);
         if (networkCode !== undefined) {
-            request['chain'] = this.networkCodeToId(networkCode).toLowerCase();
+            request['chain'] = this.networkCodeToId(networkCode, currency['code']).toLowerCase();
         }
         const version = this.options['versions']['private']['GET']['deposit-addresses'];
         this.options['versions']['private']['GET']['deposit-addresses'] = 'v1';
@@ -3484,10 +3568,11 @@ export default class kucoin extends Exchange {
                 this.checkAddress(address);
             }
         }
+        const chainId = this.safeString(depositAddress, 'chainId');
         return {
             'info': depositAddress,
             'currency': code,
-            'network': this.networkIdToCode(this.safeString(depositAddress, 'chainId')),
+            'network': this.networkIdToCode(chainId, code),
             'address': address,
             'tag': this.safeString(depositAddress, 'memo'),
         };
@@ -3496,9 +3581,11 @@ export default class kucoin extends Exchange {
      * @method
      * @name kucoin#fetchDepositAddressesByNetwork
      * @see https://www.kucoin.com/docs-new/rest/account-info/deposit/get-deposit-address-v3/en
+     * @see https://www.kucoin.com/docs-new/rest/ua/get-deposit-address
      * @description fetch the deposit address for a currency associated with this account
      * @param {string} code unified currency code
      * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {boolean} [params.uta] set to true for the unified trading account (uta) endpoint, defaults to false
      * @returns {object} an array of [address structures]{@link https://docs.ccxt.com/?id=address-structure}
      */
     async fetchDepositAddressesByNetwork(code, params = {}) {
@@ -3507,25 +3594,56 @@ export default class kucoin extends Exchange {
         const request = {
             'currency': currency['id'],
         };
-        const version = this.options['versions']['private']['GET']['deposit-addresses'];
-        this.options['versions']['private']['GET']['deposit-addresses'] = 'v2';
-        const response = await this.privateGetDepositAddresses(this.extend(request, params));
-        //
-        //     {
-        //         "code": "200000",
-        //         "data": [
-        //             {
-        //                 "address": "fr1qvus7d4d5fgxj5e7zvqe6yhxd7txm95h2and69r",
-        //                 "memo": "",
-        //                 "chain": "BTC-Segwit",
-        //                 "contractAddress": ""
-        //             },
-        //             {"address":"37icNMEWbiF8ZkwUMxmfzMxi2A1MQ44bMn","memo":"","chain":"BTC","contractAddress":""},
-        //             {"address":"Deposit temporarily blocked","memo":"","chain":"TRC20","contractAddress":""}
-        //         ]
-        //     }
-        //
-        this.options['versions']['private']['GET']['deposit-addresses'] = version;
+        let uta = await this.isUTAEnabled();
+        [uta, params] = this.handleOptionAndParams(params, 'fetchDepositAddressesByNetwork', 'uta', uta);
+        let response = undefined;
+        if (uta) {
+            let networkCode = undefined;
+            [networkCode, params] = this.handleNetworkCodeAndParams(params);
+            if (networkCode !== undefined) {
+                request['chain'] = this.networkCodeToId(networkCode).toLowerCase();
+            }
+            //
+            //     {
+            //         "code": "200000",
+            //         "data": [
+            //             {
+            //                 "address": "0xf30a9b6968183668dbce515bd6449438ab3252b3",
+            //                 "memo": "",
+            //                 "remark": "",
+            //                 "chainId": "eth",
+            //                 "to": "FUNDING",
+            //                 "expirationDate": 0,
+            //                 "currency": "USDT",
+            //                 "contractAddress": "0xdac17f958d2ee523a2206206994597c13d831ec7",
+            //                 "chainName": "ERC20"
+            //             }
+            //         ]
+            //     }
+            //
+            response = await this.utaPrivateGetAssetDepositAddress(this.extend(request, params));
+        }
+        else {
+            const version = this.options['versions']['private']['GET']['deposit-addresses'];
+            this.options['versions']['private']['GET']['deposit-addresses'] = 'v2';
+            response = await this.privateGetDepositAddresses(this.extend(request, params));
+            //
+            //     {
+            //         "code": "200000",
+            //         "data": [
+            //             {
+            //                 "address": "fr1qvus7d4d5fgxj5e7zvqe6yhxd7txm95h2and69r",
+            //                 "memo": "",
+            //                 "chain": "BTC-Segwit",
+            //                 "contractAddress": ""
+            //             },
+            //             {"address":"37icNMEWbiF8ZkwUMxmfzMxi2A1MQ44bMn","memo":"","chain":"BTC","contractAddress":""},
+            //             {"address":"Deposit temporarily blocked","memo":"","chain":"TRC20","contractAddress":""}
+            //         ]
+            //     }
+            //
+            this.options['versions']['private']['GET']['deposit-addresses'] = version;
+        }
         const chains = this.safeList(response, 'data', []);
         const parsed = this.parseDepositAddresses(chains, [currency['code']], false, {
             'currency': currency['code'],
@@ -3552,8 +3670,8 @@ export default class kucoin extends Exchange {
         const level = this.safeInteger(params, 'level', 2);
         const request = { 'symbol': market['id'] };
         const isAuthenticated = this.checkRequiredCredentials(false);
-        let uta = undefined;
-        [uta, params] = this.handleOptionAndParams(params, 'fetchOrderBook', 'uta', false);
+        let uta = false;
+        [uta, params] = this.handleOptionAndParams(params, 'fetchOrderBook', 'uta', uta);
         let response = undefined;
         let type = undefined;
         [type, params] = this.handleMarketTypeAndParams('fetchOrderBook', market, params);
@@ -3707,19 +3825,26 @@ export default class kucoin extends Exchange {
      * @see https://www.kucoin.com/docs-new/rest/futures-trading/orders/add-order
      * @see https://www.kucoin.com/docs-new/rest/futures-trading/orders/add-order-test
      * @see https://www.kucoin.com/docs-new/rest/futures-trading/orders/add-take-profit-and-stop-loss-order
+     * @see https://www.kucoin.com/docs-new/rest/ua/place-order
      * @param {string} symbol Unified CCXT market symbol
      * @param {string} type 'limit' or 'market'
      * @param {string} side 'buy' or 'sell'
      * @param {float} amount the amount of currency to trade
      * @param {float} [price] the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
      * @param {object} [params]  extra parameters specific to the exchange API endpoint
-     * Check createSpotOrder() and createContractOrder() for more details on the extra parameters that can be used in params
+     * @param {boolean} [params.uta] set to true for the unified trading account (uta) endpoint, defaults to false
+     * Check createSpotOrder(), createContractOrder() and createUtaOrder () for more details on the extra parameters that can be used in params
      * @returns {object} an [order structure]{@link https://docs.ccxt.com/?id=order-structure}
      */
     async createOrder(symbol, type, side, amount, price = undefined, params = {}) {
         await this.loadMarkets();
         const market = this.market(symbol);
-        if (market['spot']) {
+        let uta = await this.isUTAEnabled();
+        [uta, params] = this.handleOptionAndParams(params, 'createOrder', 'uta', uta);
+        if (uta) {
+            return await this.createUtaOrder(symbol, type, side, amount, price, params);
+        }
+        else if (market['spot']) {
             return await this.createSpotOrder(symbol, type, side, amount, price, params);
         }
         else if (market['contract']) {
@@ -3749,7 +3874,7 @@ export default class kucoin extends Exchange {
      * @param {float} [params.triggerPrice] The price at which a trigger order is triggered at
      * @param {string} [params.marginMode] 'cross', // cross (cross mode) and isolated (isolated mode), set to cross by default, the isolated mode will be released soon, stay tuned
      * @param {string} [params.timeInForce] GTC, GTT, IOC, or FOK, default is GTC, limit orders only
-     * @param {string} [params.postOnly] Post only flag, invalid when timeInForce is IOC or FOK
+     * @param {bool} [params.postOnly] Post only flag, invalid when timeInForce is IOC or FOK
      *
      * EXCHANGE SPECIFIC PARAMETERS
      * @param {string} [params.clientOid] client order id, defaults to uuid if not passed
@@ -3942,7 +4067,7 @@ export default class kucoin extends Exchange {
      * @param {float} [params.takeProfitPrice] price to trigger take-profit orders
      * @param {bool} [params.reduceOnly] A mark to reduce the position size only. Set to false by default. Need to set the position size when reduceOnly is true.
      * @param {string} [params.timeInForce] GTC, GTT, IOC, or FOK, default is GTC, limit orders only
-     * @param {string} [params.postOnly] Post only flag, invalid when timeInForce is IOC or FOK
+     * @param {bool} [params.postOnly] Post only flag, invalid when timeInForce is IOC or FOK
      * @param {float} [params.cost] the cost of the order in units of USDT
      * @param {string} [params.marginMode] 'cross' or 'isolated', default is 'isolated'
      * @param {bool} [params.hedged] *swap and future only* true for hedged mode, false for one way mode, default is false
@@ -4112,6 +4237,223 @@ export default class kucoin extends Exchange {
         params = this.omit(params, ['timeInForce', 'stopPrice', 'triggerPrice', 'stopLossPrice', 'takeProfitPrice', 'reduceOnly', 'hedged']); // Time in force only valid for limit orders, exchange error when gtc for market orders
         return this.extend(request, params);
     }
+    /**
+     * @method
+     * @name kucoin#createUtaOrder
+     * @description helper method for creating uta orders
+     * @see https://www.kucoin.com/docs-new/rest/ua/place-order
+     * @param {string} symbol Unified CCXT market symbol
+     * @param {string} type 'limit' or 'market'
+     * @param {string} side 'buy' or 'sell'
+     * @param {float} amount the amount of currency to trade
+     * @param {float} [price] the price at which the order is to be fulfilled, in units of the quote currency, ignored in market orders
+     * @param {object} [params]  extra parameters specific to the exchange API endpoint
+     * @param {string} [params.clientOrderId] client order id, defaults to uuid if not passed
+     * @param {float} [params.cost] the cost of the order in units of quote currency
+     * @param {string} [params.timeInForce] GTC, GTD, IOC, FOK or PO
+     * @param {bool} [params.postOnly] Post only flag, invalid when timeInForce is IOC or FOK (default is false)
+     * @param {bool} [params.reduceOnly] *contract markets only* A mark to reduce the position size only. Set to false by default
+     * @param {float} [params.triggerPrice] The price a trigger order is triggered at
+     * @param {string} [params.triggerDirection] 'ascending' or 'descending', the direction the triggerPrice is triggered from, requires triggerPrice
+     * @param {string} [params.triggerPriceType] *contract markets only* "last", "mark", "index" - defaults to "mark"
+     * @param {float} [params.stopLossPrice] price to trigger stop-loss orders
+     * @param {float} [params.takeProfitPrice] price to trigger take-profit orders
+     * @param {string} [params.marginMode] 'cross' or 'isolated', (default is 'cross' for margin orders, default is 'isolated' for contract orders)
+     *
+     * Exchange-specific parameters -------------------------------------------------
+     * @param {string} [params.accountMode] 'unified' or 'classic', default is 'unified'
+     * @param {string} [params.stp] '', // self trade prevention, CN, CO, CB or DC
+     * @param {int} [params.cancelAfter] - Cancel After N Seconds (Calculated from the time of entering the matching engine), only effective when timeInForce is GTD
+     * @param {string} [params.sizeUnit] *contracts only* 'BASECCY' (amount of base currency) or 'UNIT' (number of contracts), default is 'UNIT'
+     *
+     * Classic account parameters
+     * @param {bool} [params.autoBorrow] *classic margin orders only*
+     * @param {bool} [params.autoRepay] *classic margin orders only*
+     * @param {string} [params.hedged] *classic contract orders only* true for hedged mode, false for one way mode, default is false
+     * @param {int} [params.leverage] *classic contract orders with isolated marginMode only* Leverage size of the order
+     * @returns {object} an [order structure]{@link https://docs.ccxt.com/?id=order-structure}
+     */
+    async createUtaOrder(symbol, type, side, amount, price = undefined, params = {}) {
+        await this.loadMarkets();
+        const request = this.createUtaOrderRequest(symbol, type, side, amount, price, params);
+        const response = await this.utaPrivatePostAccountModeOrderPlace(request);
+        //
+        //     {
+        //         "code": "200000",
+        //         "data": {
+        //             "orderId": "426319129738321920",
+        //             "tradeType": "SPOT",
+        //             "ts": 1774455603216000000,
+        //             "clientOid": "b896c118-a674-4863-baf4-a9ea3cd696c5"
+        //         }
+        //     }
+        //
+        const data = this.safeDict(response, 'data', {});
+        return this.parseOrder(data);
+    }
+    createUtaOrderRequest(symbol, type, side, amount, price = undefined, params = {}) {
+        const market = this.market(symbol);
+        const isSpot = market['spot'];
+        const isContract = market['contract'];
+        let accountMode = 'unified';
+        [accountMode, params] = this.handleOptionAndParams(params, 'createOrder', 'accountMode', accountMode);
+        const isUnified = (accountMode === 'unified');
+        let marginMode = undefined;
+        [marginMode, params] = this.handleMarginModeAndParams('createOrder', params);
+        const marginModeDefined = (marginMode !== undefined);
+        const isSpotMargin = (isSpot && marginModeDefined);
+        if (isSpotMargin && isUnified) {
+            throw new NotSupported(this.id + ' createOrder() does not support spot margin orders with unified accountMode');
+        }
+        const tradeType = this.handleTradeType(isContract, marginMode, params);
+        const clientOrderId = this.safeString2(params, 'clientOid', 'clientOrderId', this.uuid());
+        params = this.omit(params, ['clientOid', 'clientOrderId']);
+        const request = {
+            'accountMode': accountMode,
+            'tradeType': tradeType,
+            'clientOid': clientOrderId,
+            'symbol': market['id'],
+            // 'triggerDirection'- 'UP' or 'DOWN (required for trigger orders, supported for classic-FUTURES and unified-SPOT and unified-FUTURES)
+            // 'triggerPriceType' - 'TP', 'IP', 'MP' (required for trigger orders, supported for classic-FUTURES and unified-SPOT and unified-FUTURES)
+            // 'triggerPrice' (required for trigger orders)
+            'side': side.toUpperCase(),
+            'orderType': type.toUpperCase(),
+            // 'size'
+            // 'sizeUnit' - 'BASECCY', 'QUOTECCY' (for market SPOT) or 'UNIT' (for unified-FUTURES)
+            // 'price'
+            // 'timeInForce' - 'GTC', 'IOC', 'FOK', 'GTT' or 'RPI' (GTT is not supported for FUTURES)
+            // 'postOnly'
+            // 'reduceOnly' (only for FUTURES)
+            // 'stp' - 'CN', 'CO', 'CB' or 'DC' (DC is not supported for FUTURES)
+            // 'cancelAfter' - time in seconds (only valid when timeInForce is GTT, not supported for FUTURES)
+            // 'tags'
+            // 'autoBorrow' (only for classic-CROSS and classic-ISOLATED)
+            // 'autoRepay' (only for classic-CROSS and classic-ISOLATED)
+            // 'positionSide' - 'BOTH', 'LONG' or 'SHORT' (only for classic-FUTURES)
+            // 'marginMode' - 'ISOLATED' or 'CROSS' (only for classic-FUTURES, default is 'ISOLATED')
+            // 'leverage' (only for classic-FUTURES-ISOLATED, required)
+            // 'tpTriggerPriceType' - 'TP', 'IP', 'MP' (only for unified-FUTURES and classic-FUTURES)
+            // 'tpTriggerPrice' (only for unified-FUTURES and classic-FUTURES)
+            // 'slTriggerPriceType' - 'TP', 'IP', 'MP' (only for unified-FUTURES and classic-FUTURES)
+            // 'slTriggerPrice' (only for unified-FUTURES and classic-FUTURES)
+        };
+        if (tradeType !== undefined) {
+            request['tradeType'] = tradeType;
+        }
+        request['clientOid'] = clientOrderId;
+        const isMarketOrder = (type === 'market');
+        const cost = this.safeString(params, 'cost');
+        if (cost !== undefined) {
+            params = this.omit(params, 'cost');
+            if (isSpot && isMarketOrder) {
+                request['sizeUnit'] = 'QUOTECCY';
+                request['size'] = this.marketOrderAmountToPrecision(symbol, cost);
+            }
+            else {
+                throw new NotSupported(this.id + ' createOrder() with cost is supported for spot market orders only');
+            }
+        }
+        else {
+            let sizeUnit = 'BASECCY';
+            if (isContract) {
+                [sizeUnit, params] = this.handleOptionAndParams(params, 'createOrder', 'sizeUnit', 'UNIT');
+            }
+            request['sizeUnit'] = sizeUnit;
+            request['size'] = this.amountToPrecision(symbol, amount);
+        }
+        if (!isMarketOrder) {
+            request['price'] = this.priceToPrecision(symbol, price);
+        }
+        let postOnly = undefined;
+        [postOnly, params] = this.handlePostOnly(isMarketOrder, false, params);
+        const timeInForce = this.handleTimeInForce(params);
+        if ((timeInForce !== undefined)) {
+            params = this.omit(params, 'timeInForce');
+            request['timeInForce'] = timeInForce;
+        }
+        if (postOnly) {
+            request['postOnly'] = true;
+        }
+        if (isContract) {
+            if (!isUnified) {
+                if (marginModeDefined) {
+                    request['marginMode'] = marginMode.toUpperCase();
+                    if (marginMode === 'isolated') {
+                        const leverage = this.safeInteger(params, 'leverage');
+                        if (leverage === undefined) {
+                            request['leverage'] = 1;
+                        }
+                    }
+                }
+                const reduceOnly = this.safeBool(params, 'reduceOnly', false);
+                let hedged = false;
+                [hedged, params] = this.handleParamBool(params, 'hedged', hedged);
+                if (hedged) {
+                    let positionSide = (side === 'buy') ? 'LONG' : 'SHORT';
+                    if (reduceOnly) {
+                        positionSide = (positionSide === 'LONG') ? 'SHORT' : 'LONG';
+                    }
+                    request['positionSide'] = positionSide;
+                }
+            }
+        }
+        // handling with coinditional orders
+        const [triggerPrice, stopLossPrice, takeProfitPrice] = this.handleTriggerPrices(params);
+        const stopLoss = this.safeDict(params, 'stopLoss');
+        const takeProfit = this.safeDict(params, 'takeProfit');
+        const hasStopLoss = stopLoss !== undefined;
+        const hasTakeProfit = takeProfit !== undefined;
+        const triggerPriceTypes = {
+            'mark': 'MP',
+            'last': 'TP',
+            'index': 'IP',
+        };
+        if (triggerPrice) {
+            const triggerDirection = this.safeString(params, 'triggerDirection');
+            if (triggerDirection === undefined) {
+                throw new ArgumentsRequired(this.id + ' createOrder() requires a triggerDirection parameter for trigger orders. Provide params.tringgerDirection or use params.stopLossPrice or params.takeProfitPrice instead of params.triggerPrice');
+            }
+            request['triggerDirection'] = (triggerDirection === 'ascending') ? 'UP' : 'DOWN';
+            request['triggerPrice'] = this.priceToPrecision(symbol, triggerPrice);
+        }
+        else if (hasStopLoss || hasTakeProfit) {
+            if (!isContract) {
+                throw new NotSupported(this.id + ' createOrder() stopLoss and takeProfit parameters are only supported for contract orders');
+            }
+            if (hasStopLoss) {
+                const slTriggerPrice = this.safeString2(stopLoss, 'triggerPrice', 'stopPrice');
+                const slTriggerPriceType = this.safeString(stopLoss, 'triggerPriceType', 'mark');
+                request['slTriggerPrice'] = this.priceToPrecision(symbol, slTriggerPrice);
+                request['slTriggerPriceType'] = this.safeString(triggerPriceTypes, slTriggerPriceType, slTriggerPriceType);
+            }
+            if (hasTakeProfit) {
+                const tpTriggerPrice = this.safeString2(takeProfit, 'triggerPrice', 'takeProfitPrice');
+                const tpTriggerPriceType = this.safeString(takeProfit, 'triggerPriceType', 'mark');
+                request['tpTriggerPrice'] = this.priceToPrecision(symbol, tpTriggerPrice);
+                request['tpTriggerPriceType'] = this.safeString(triggerPriceTypes, tpTriggerPriceType, tpTriggerPriceType);
+            }
+        }
+        else if (stopLossPrice || takeProfitPrice) {
+            if (stopLossPrice) {
+                request['triggerDirection'] = (side === 'buy') ? 'UP' : 'DOWN';
+                request['triggerPrice'] = this.priceToPrecision(symbol, stopLossPrice);
+                if (isContract) {
+                    const stopLossPriceType = this.safeString2(params, 'stopLossPriceType', 'triggerPriceType', 'mark');
+                    request['triggerPriceType'] = this.safeString(triggerPriceTypes, stopLossPriceType, stopLossPriceType);
+                }
+            }
+            else {
+                request['triggerDirection'] = (side === 'buy') ? 'DOWN' : 'UP';
+                request['triggerPrice'] = this.priceToPrecision(symbol, takeProfitPrice);
+                if (isContract) {
+                    const takeProfitPriceType = this.safeString2(params, 'takeProfitPriceType', 'triggerPriceType', 'mark');
+                    request['triggerPriceType'] = this.safeString(triggerPriceTypes, takeProfitPriceType, takeProfitPriceType);
+                }
+            }
+        }
+        params = this.omit(params, ['triggerPrice', 'stopLossPrice', 'takeProfitPrice', 'stopPriceType', 'stopLossPriceType', 'takeProfitPriceType', 'triggerPriceType', 'triggerDirection', 'stopLoss', 'takeProfit', 'hedged']);
+        return this.extend(request, params);
+    }
     /**
      * @method
      * @name kucoin#createMarketOrderWithCost
@@ -4403,16 +4745,23 @@ export default class kucoin extends Exchange {
      * @see https://www.kucoin.com/docs-new/rest/margin-trading/orders/cancel-stop-order-by-clientoid
      * @see https://www.kucoin.com/docs-new/rest/futures-trading/orders/cancel-order-by-orderld
      * @see https://www.kucoin.com/docs-new/rest/futures-trading/orders/cancel-order-by-clientoid
+     * @see https://www.kucoin.com/docs-new/rest/ua/cancel-order
      * @param {string} id order id
      * @param {string} symbol unified symbol of the market the order was made in
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @param {string} [params.type] 'spot' or 'swap', used if symbol is not provided (default is 'spot')
      * @param {string} [params.marginMode] *spot only* 'cross' or 'isolated'
+     * @param {boolean} [params.uta] true for cancelling order with unified account endpoint (default is false)
      * Check cancelSpotOrder() and cancelContractOrder() for more details on the extra parameters that can be used in params
      * @returns Response from the exchange
      */
     async cancelOrder(id, symbol = undefined, params = {}) {
         await this.loadMarkets();
+        let uta = await this.isUTAEnabled();
+        [uta, params] = this.handleOptionAndParams(params, 'cancelOrder', 'uta', uta);
+        if (uta) {
+            return await this.cancelUtaOrder(id, symbol, params);
+        }
         let marketType = undefined;
         let market = undefined;
         if (symbol !== undefined) {
@@ -4629,6 +4978,61 @@ export default class kucoin extends Exchange {
         //
         return this.safeOrder({ 'info': response });
     }
+    /**
+     * @method
+     * @name kucoin#cancelUtaOrder
+     * @description helper method for cancelling uta orders
+     * @see https://www.kucoin.com/docs-new/rest/ua/cancel-order
+     * @param {string} id order id
+     * @param {string} symbol unified symbol of the market the order was made in
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {string} [params.accountMode] 'unified' or 'classic' (default is 'unified')
+     * @param {string} [params.clientOrderId] client order id, required if id is not provided
+     * @param {string} [params.marginMode] 'cross' or 'isolated', required if fetching a margin order
+     * @returns Response from the exchange
+     */
+    async cancelUtaOrder(id, symbol = undefined, params = {}) {
+        if (symbol === undefined) {
+            throw new ArgumentsRequired(this.id + ' cancelOrder() requires a symbol argument for uta endpoint');
+        }
+        await this.loadMarkets();
+        const request = {};
+        const clientOrderId = this.safeString2(params, 'clientOid', 'clientOrderId');
+        if (clientOrderId !== undefined) {
+            request['clientOid'] = clientOrderId;
+            params = this.omit(params, ['clientOid', 'clientOrderId']);
+        }
+        else {
+            if (id === undefined) {
+                throw new ArgumentsRequired(this.id + ' fetchOrder() requires an id argument or clientOrderId parameter');
+            }
+            request['orderId'] = id;
+        }
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        request['symbol'] = market['id'];
+        let accountMode = 'unified';
+        [accountMode, params] = this.handleOptionAndParams(params, 'fetchOrder', 'accountMode', accountMode);
+        request['accountMode'] = accountMode;
+        let marginMode = undefined;
+        [marginMode, params] = this.handleMarginModeAndParams('fetchOrder', params);
+        const tradeType = this.handleTradeType(market['contract'], marginMode, params);
+        request['tradeType'] = tradeType;
+        const response = await this.utaPrivatePostAccountModeOrderCancel(this.extend(request, params));
+        //
+        //     {
+        //         "code": "200000",
+        //         "data": {
+        //             "orderId": "426319129738321920",
+        //             "tradeType": "SPOT",
+        //             "ts": 1774457628105000000,
+        //             "clientOid": "b896c118-a674-4863-baf4-a9ea3cd696c5"
+        //         }
+        //     }
+        //
+        const data = this.safeDict(response, 'data', {});
+        return this.parseOrder(data, market);
+    }
     /**
      * @method
      * @name kucoin#cancelAllOrders
@@ -4640,14 +5044,22 @@ export default class kucoin extends Exchange {
      * @see https://www.kucoin.com/docs-new/rest/margin-trading/orders/batch-cancel-stop-orders
      * @see https://www.kucoin.com/docs-new/rest/futures-trading/orders/cancel-all-orders
      * @see https://www.kucoin.com/docs-new/rest/futures-trading/orders/cancel-all-stop-orders
+     * @see https://www.kucoin.com/docs-new/rest/ua/batch-cancel-order-by-symbol
      * @param {string} symbol unified market symbol, only orders in the market of this symbol are cancelled when symbol is not undefined
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @param {string} [params.type] 'spot' or 'swap', used if symbol is not provided (default is 'spot')
      * @param {string} [params.marginMode] *spot only* 'cross' or 'isolated'
+     * @param {boolean} [params.uta] true for cancelling orders with unified account endpoint (default is false)
+     * Check cancelAllSpotOrders(), cancelAllContractOrders() and cancelAllUtaOrders() for more details on the extra parameters that can be used in params
      * @returns Response from the exchange
      */
     async cancelAllOrders(symbol = undefined, params = {}) {
         await this.loadMarkets();
+        let uta = await this.isUTAEnabled();
+        [uta, params] = this.handleOptionAndParams(params, 'cancelAllOrders', 'uta', uta);
+        if (uta) {
+            return await this.cancelAllUtaOrders(symbol, params);
+        }
         let marketType = undefined;
         let market = undefined;
         if (symbol !== undefined) {
@@ -4765,26 +5177,78 @@ export default class kucoin extends Exchange {
     }
     /**
      * @method
-     * @name kucoin#fetchOrdersByStatus
-     * @description fetches a list of orders placed on the exchange
-     * @see https://www.kucoin.com/docs-new/rest/spot-trading/orders/get-open-orders
-     * @see https://www.kucoin.com/docs-new/rest/spot-trading/orders/get-closed-orders
-     * @see https://www.kucoin.com/docs-new/rest/spot-trading/orders/get-stop-orders-list
-     * @see https://www.kucoin.com/docs-new/rest/margin-trading/orders/get-open-orders
-     * @see https://www.kucoin.com/docs-new/rest/margin-trading/orders/get-closed-orders
-     * @see https://www.kucoin.com/docs-new/rest/margin-trading/orders/get-stop-order-list
-     * @see https://www.kucoin.com/docs-new/rest/futures-trading/orders/get-order-list
-     * @see https://www.kucoin.com/docs-new/rest/futures-trading/orders/get-stop-order-list
-     * @param {string} status 'active' or 'closed', only 'active' is valid for stop orders
-     * @param {string} symbol unified symbol for the market to retrieve orders from
-     * @param {int} [since] timestamp in ms of the earliest order to retrieve
-     * @param {int} [limit] The maximum number of orders to retrieve
+     * @name kucoin#cancelAllUtaOrders
+     * @description helper method for cancelling all uta orders
+     * @see https://www.kucoin.com/docs-new/rest/ua/batch-cancel-order-by-symbol
+     * @param {string} symbol unified market symbol, only orders in the market of this symbol are cancelled when symbol is not undefined
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {bool} [params.trigger] true if cancelling all stop orders
+     * @param {string} [params.marginMode] 'CROSS' or 'ISOLATED'
+     * @returns Response from the exchange
+     */
+    async cancelAllUtaOrders(symbol = undefined, params = {}) {
+        if (symbol === undefined) {
+            throw new ArgumentsRequired(this.id + ' cancelAllOrders() requires a symbol argument for uta endpoint');
+        }
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const isContract = market['contract'];
+        const tradeType = isContract ? 'FUTURES' : 'SPOT';
+        let trigger = false;
+        [trigger, params] = this.handleParamBool(params, 'trigger', trigger);
+        const orderFilter = trigger ? 'ADVANCED' : 'NORMAL';
+        const request = {
+            'accountMode': 'unified',
+            'symbol': market['id'],
+            'tradeType': tradeType,
+            'orderFilter': orderFilter,
+        };
+        const response = await this.utaPrivatePostAccountModeOrderCancelAll(this.extend(request, params));
+        //
+        //     {
+        //         "code": "200000",
+        //         "data": {
+        //             "tradeType": "SPOT",
+        //             "ts": 1774458644140000000,
+        //             "items": [
+        //                 {
+        //                     "orderId": "426328635071352832"
+        //                 }
+        //             ]
+        //         }
+        //     }
+        //
+        const data = this.safeDict(response, 'data', {});
+        const orders = this.safeList(data, 'items', []);
+        return this.parseOrders(orders, market, undefined, undefined, { 'status': 'canceled' });
+    }
+    /**
+     * @method
+     * @name kucoin#fetchOrdersByStatus
+     * @description fetches a list of orders placed on the exchange
+     * @see https://www.kucoin.com/docs-new/rest/spot-trading/orders/get-open-orders
+     * @see https://www.kucoin.com/docs-new/rest/spot-trading/orders/get-closed-orders
+     * @see https://www.kucoin.com/docs-new/rest/spot-trading/orders/get-stop-orders-list
+     * @see https://www.kucoin.com/docs-new/rest/margin-trading/orders/get-open-orders
+     * @see https://www.kucoin.com/docs-new/rest/margin-trading/orders/get-closed-orders
+     * @see https://www.kucoin.com/docs-new/rest/margin-trading/orders/get-stop-order-list
+     * @see https://www.kucoin.com/docs-new/rest/futures-trading/orders/get-order-list
+     * @see https://www.kucoin.com/docs-new/rest/futures-trading/orders/get-stop-order-list
+     * @see https://www.kucoin.com/docs-new/rest/ua/get-open-order-list
+     * @see https://www.kucoin.com/docs-new/rest/ua/get-order-history
+     * @param {string} status 'active' or 'closed', only 'active' is valid for stop orders
+     * @param {string} symbol unified symbol for the market to retrieve orders from
+     * @param {int} [since] timestamp in ms of the earliest order to retrieve
+     * @param {int} [limit] The maximum number of orders to retrieve
      * @param {object} [params] exchange specific parameters
-     * Check fetchSpotOrdersByStatus() and fetchContractOrdersByStatus() for more details on the extra parameters that can be used in params
+     * @param {boolean} [params.uta] true for fetch orders with uta endpoint (default is false)
+     * Check fetchSpotOrdersByStatus(), fetchContractOrdersByStatus() and fetchUtaOrdersByStatus() for more details on the extra parameters that can be used in params
      * @returns An [array of order structures]{@link https://docs.ccxt.com/?id=order-structure}
      */
     async fetchOrdersByStatus(status, symbol = undefined, since = undefined, limit = undefined, params = {}) {
         await this.loadMarkets();
+        let uta = await this.isUTAEnabled();
+        [uta, params] = this.handleOptionAndParams(params, 'fetchOrdersByStatus', 'uta', uta);
         let marketType = undefined;
         if (symbol === undefined) {
             const type = this.safeString(params, 'type'); // exchange has specific param for order type
@@ -4794,14 +5258,26 @@ export default class kucoin extends Exchange {
                 params = this.omit(params, 'type');
             }
             else {
-                [marketType, params] = this.handleMarketTypeAndParams('fetchOrdersByStatus', undefined, {});
+                const methodOptions = this.safeDict(this.options, 'fetchOrdersByStatus', {});
+                const methodDefaultType = this.safeString2(methodOptions, 'defaultType', 'type');
+                if (methodDefaultType === undefined) {
+                    marketType = this.safeString2(this.options, 'defaultType', 'type', 'spot');
+                }
+                else {
+                    marketType = methodDefaultType;
+                }
             }
         }
         else {
             const market = this.market(symbol);
             marketType = market['type'];
         }
-        if ((marketType === 'spot') || (marketType === 'margin')) {
+        if (uta) {
+            params = this.omit(params, 'uta');
+            params = this.extend(params, { 'marketType': marketType });
+            return await this.fetchUtaOrdersByStatus(status, symbol, since, limit, params);
+        }
+        else if ((marketType === 'spot') || (marketType === 'margin')) {
             return await this.fetchSpotOrdersByStatus(status, symbol, since, limit, params);
         }
         else {
@@ -5066,6 +5542,128 @@ export default class kucoin extends Exchange {
         const orders = this.safeList(responseData, 'items', []);
         return this.parseOrders(orders, market, since, limit);
     }
+    /**
+     * @method
+     * @name kucoin#fetchUtaOrdersByStatus
+     * @description helper method for fetching orders by status with uta endpoint
+     * @see https://www.kucoin.com/docs-new/rest/ua/get-open-order-list
+     * @see https://www.kucoin.com/docs-new/rest/ua/get-order-history
+     * @param {string} status 'active' or 'closed', only 'active' is valid for stop orders
+     * @param {string} symbol unified symbol for the market to retrieve orders from
+     * @param {int} [since] timestamp in ms of the earliest order to retrieve
+     * @param {int} [limit] The maximum number of orders to retrieve
+     * @param {object} [params] exchange specific parameters
+     * @param {int} [params.until] End time in ms
+     * @param {string} [params.side] *closed orders only* 'BUY' or 'SELL'
+     * @param {string} [params.accountMode] 'unified' or 'classic' (default is unified)
+     * @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)
+     * @returns An [array of order structures]{@link https://docs.ccxt.com/?id=order-structure}
+     */
+    async fetchUtaOrdersByStatus(status, symbol = undefined, since = undefined, limit = undefined, params = {}) {
+        await this.loadMarkets();
+        let paginate = false;
+        const maxLimit = 200;
+        [paginate, params] = this.handleOptionAndParams(params, 'fetchOrdersByStatus', 'paginate');
+        if (paginate) {
+            return await this.fetchPaginatedCallDynamic('fetchOrdersByStatus', symbol, since, limit, params, maxLimit);
+        }
+        let accountMode = 'unified';
+        [accountMode, params] = this.handleOptionAndParams(params, 'fetchUtaOrdersByStatus', 'accountMode', accountMode);
+        let request = {
+            'accountMode': accountMode,
+        };
+        let marketType = undefined;
+        let market = undefined;
+        if (symbol !== undefined) {
+            market = this.market(symbol);
+            marketType = market['type'];
+            request['symbol'] = market['id'];
+        }
+        else {
+            marketType = this.safeString(params, 'marketType');
+        }
+        params = this.omit(params, 'marketType');
+        const isContract = (marketType !== 'spot') && (marketType !== 'margin');
+        if (!isContract && (symbol === undefined)) {
+            throw new ArgumentsRequired(this.id + ' fetchOrdersByStatus() requires a symbol argument for spot and margin markets when using uta endpoint');
+        }
+        let marginMode = undefined;
+        [marginMode, params] = this.handleMarginModeAndParams('fetchOrdersByStatus', params);
+        const tradeType = this.handleTradeType(isContract, marginMode, params);
+        params['tradeType'] = tradeType;
+        if (since !== undefined) {
+            request['startAt'] = since;
+        }
+        [request, params] = this.handleUntilOption('endAt', request, params);
+        if (limit !== undefined) {
+            request['pageSize'] = limit;
+        }
+        let lowercaseStatus = status.toLowerCase();
+        if (lowercaseStatus === 'open') {
+            lowercaseStatus = 'active';
+        }
+        else if (lowercaseStatus === 'closed') {
+            lowercaseStatus = 'done';
+        }
+        let response = undefined;
+        if (lowercaseStatus === 'active') {
+            //
+            //     {
+            //         "code": "200000",
+            //         "data": {
+            //             "pageNumber": 1,
+            //             "pageSize": 50,
+            //             "totalNum": 1,
+            //             "totalPage": 1,
+            //             "items": [
+            //                 {
+            //                     "orderId": "426328635071352832",
+            //                     "symbol": "ETH-USDT",
+            //                     "orderType": "LIMIT",
+            //                     "side": "BUY",
+            //                     "size": "0.001",
+            //                     "price": "1000",
+            //                     "timeInForce": "GTC",
+            //                     "tags": "partner:ccxt",
+            //                     "orderTime": 1774457869404794617,
+            //                     "stp": "",
+            //                     "cancelAfter": null,
+            //                     "postOnly": false,
+            //                     "reduceOnly": false,
+            //                     "triggerDirection": "",
+            //                     "triggerPrice": "",
+            //                     "triggerPriceType": "",
+            //                     "tpTriggerPrice": "",
+            //                     "tpTriggerPriceType": "",
+            //                     "slTriggerPrice": "",
+            //                     "slTriggerPriceType": "",
+            //                     "filledSize": "0",
+            //                     "avgPrice": "0",
+            //                     "fee": "0",
+            //                     "feeCurrency": "USDT",
+            //                     "tax": "0",
+            //                     "updatedTime": 1774457869469028819,
+            //                     "triggerOrderId": "",
+            //                     "cancelReason": "",
+            //                     "cancelSize": "0",
+            //                     "clientOid": "708987d5-c346-487a-a70c-ea267377b0ca",
+            //                     "sizeUnit": "BASECCY",
+            //                     "status": 2
+            //                 }
+            //             ],
+            //             "tradeType": "SPOT"
+            //         }
+            //     }
+            //
+            response = await this.utaPrivateGetAccountModeOrderOpenList(this.extend(request, params));
+        }
+        else {
+            response = await this.utaPrivateGetAccountModeOrderHistory(this.extend(request, params));
+        }
+        const data = this.safeDict(response, 'data', {});
+        const orders = this.safeList(data, 'items', []);
+        return this.parseOrders(orders, market, since, limit);
+    }
     /**
      * @method
      * @name kucoin#fetchClosedOrders
@@ -5076,6 +5674,7 @@ export default class kucoin extends Exchange {
      * @see https://www.kucoin.com/docs-new/rest/futures-trading/orders/get-stop-order-list
      * @see https://www.kucoin.com/docs-new/rest/margin-trading/orders/get-open-orders
      * @see https://www.kucoin.com/docs-new/rest/margin-trading/orders/get-closed-orders
+     * @see https://www.kucoin.com/docs-new/rest/ua/get-order-history
      * @param {string} symbol unified market symbol of the market orders were made in
      * @param {int} [since] the earliest time in ms to fetch orders for
      * @param {int} [limit] the maximum number of order structures to retrieve
@@ -5109,6 +5708,7 @@ export default class kucoin extends Exchange {
      * @see https://www.kucoin.com/docs-new/rest/margin-trading/orders/get-open-orders
      * @see https://www.kucoin.com/docs-new/rest/margin-trading/orders/get-closed-orders
      * @see https://www.kucoin.com/docs-new/rest/margin-trading/orders/get-stop-order-list
+     * @see https://www.kucoin.com/docs-new/rest/ua/get-open-order-list
      * @param {string} symbol unified market symbol
      * @param {int} [since] the earliest time in ms to fetch open orders for
      * @param {int} [limit] the maximum number of  open orders structures to retrieve
@@ -5147,15 +5747,23 @@ export default class kucoin extends Exchange {
      * @see https://www.kucoin.com/docs-new/rest/margin-trading/orders/get-stop-order-by-clientoid
      * @see https://www.kucoin.com/docs-new/rest/futures-trading/orders/get-order-by-orderld
      * @see https://www.kucoin.com/docs-new/rest/futures-trading/get-stop-order-by-clientoid
+     * @see https://www.kucoin.com/docs-new/rest/ua/get-order-details
      * @param {string} id order id
      * @param {string} symbol unified symbol of the market the order was made in
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @param {string} [params.type] 'spot' or 'swap', used if symbol is not provided (default is 'spot')
-     * Check fetchSpotOrder() and fetchContractOrder() for more details on the extra parameters that can be used in params
+     * @param {bool} [params.uta] true if fetching an order with uta endpoint (default is false)
+     * Check fetchSpotOrder(), fetchContractOrder() and fetchUtaOrder() for more details on the extra parameters that can be used in params
      * @returns {object} An [order structure]{@link https://docs.ccxt.com/?id=order-structure}
      */
     async fetchOrder(id, symbol = undefined, params = {}) {
         await this.loadMarkets();
+        let uta = await this.isUTAEnabled();
+        [uta, params] = this.handleOptionAndParams(params, 'fetchOrder', 'uta', uta);
+        if (uta) {
+            params = this.omit(params, 'uta');
+            return await this.fetchUtaOrder(id, symbol, params);
+        }
         let marketType = undefined;
         if (symbol === undefined) {
             [marketType, params] = this.handleMarketTypeAndParams('fetchOrder', undefined, params);
@@ -5346,7 +5954,115 @@ export default class kucoin extends Exchange {
         const responseData = this.safeDict(response, 'data');
         return this.parseOrder(responseData, market);
     }
+    /**
+     * @method
+     * @name kucoin#fetchUtaOrder
+     * @description fetch uta order
+     * @see https://www.kucoin.com/docs-new/rest/ua/get-order-details
+     * @param {string} id order id
+     * @param {string} symbol unified symbol of the market the order was made in
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {string} [params.accountMode] 'unified' or 'classic' (default is 'unified')
+     * @param {string} [params.clientOrderId] client order id, required if id is not provided
+     * @param {string} [params.marginMode] 'cross' or 'isolated', required if fetching a margin order
+     * @returns {object} An [order structure]{@link https://docs.ccxt.com/?id=order-structure}
+     */
+    async fetchUtaOrder(id, symbol = undefined, params = {}) {
+        if (symbol === undefined) {
+            throw new ArgumentsRequired(this.id + ' fetchOrder() requires a symbol argument for uta orders');
+        }
+        const request = {};
+        const clientOrderId = this.safeString2(params, 'clientOid', 'clientOrderId');
+        if (clientOrderId !== undefined) {
+            request['clientOid'] = clientOrderId;
+            params = this.omit(params, ['clientOid', 'clientOrderId']);
+        }
+        else {
+            if (id === undefined) {
+                throw new ArgumentsRequired(this.id + ' fetchOrder() requires an id argument or clientOrderId parameter');
+            }
+            request['orderId'] = id;
+        }
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        request['symbol'] = market['id'];
+        let accountMode = 'unified';
+        [accountMode, params] = this.handleOptionAndParams(params, 'fetchOrder', 'accountMode', accountMode);
+        request['accountMode'] = accountMode;
+        let marginMode = undefined;
+        [marginMode, params] = this.handleMarginModeAndParams('fetchOrder', params);
+        const tradeType = this.handleTradeType(market['contract'], marginMode, params);
+        request['tradeType'] = tradeType;
+        const response = await this.utaPrivateGetAccountModeOrderDetail(this.extend(request, params));
+        //
+        //     {
+        //         "code": "200000",
+        //         "data": {
+        //             "orderId": "426319129738321920",
+        //             "symbol": "ETH-USDT",
+        //             "orderType": "LIMIT",
+        //             "side": "BUY",
+        //             "size": "0.001",
+        //             "price": "1000",
+        //             "timeInForce": "GTC",
+        //             "tags": "partner:ccxt",
+        //             "orderTime": 1774455603156417582,
+        //             "stp": "",
+        //             "cancelAfter": null,
+        //             "postOnly": false,
+        //             "reduceOnly": false,
+        //             "triggerDirection": "",
+        //             "triggerPrice": "",
+        //             "triggerPriceType": "",
+        //             "tpTriggerPrice": "",
+        //             "tpTriggerPriceType": "",
+        //             "slTriggerPrice": "",
+        //             "slTriggerPriceType": "",
+        //             "filledSize": "0",
+        //             "avgPrice": "0",
+        //             "fee": "0",
+        //             "feeCurrency": "USDT",
+        //             "tax": "0",
+        //             "updatedTime": 1774455603371523690,
+        //             "triggerOrderId": "",
+        //             "cancelReason": "",
+        //             "cancelSize": "0",
+        //             "clientOid": "b896c118-a674-4863-baf4-a9ea3cd696c5",
+        //             "sizeUnit": "BASECCY",
+        //             "tradeType": "SPOT",
+        //             "tradeId": "",
+        //             "status": 2
+        //         }
+        //     }
+        //
+        const data = this.safeDict(response, 'data', {});
+        return this.parseOrder(data, market);
+    }
+    handleTradeType(isContractMarket = false, marginMode = undefined, params = {}) {
+        let tradeType = this.safeString(params, 'tradeType');
+        if (tradeType === undefined) {
+            if (isContractMarket) {
+                tradeType = 'FUTURES';
+            }
+            else if (marginMode !== undefined) {
+                tradeType = marginMode.toUpperCase();
+            }
+            else {
+                tradeType = 'SPOT';
+            }
+        }
+        return tradeType;
+    }
     parseOrder(order, market = undefined) {
+        const tradeType = this.safeString(order, 'tradeType');
+        const utaTradeTypes = ['SPOT', 'CROSS', 'ISOLATED', 'FUTURES']; // tradeType specific for uta endpoint
+        let isUtaOrder = this.inArray(tradeType, utaTradeTypes);
+        if ('sizeUnit' in order) { // property specific for uta endpoint
+            isUtaOrder = true;
+        }
+        if (isUtaOrder) {
+            return this.parseUtaOrder(order, market);
+        }
         const marketId = this.safeString(order, 'symbol');
         market = this.safeMarket(marketId, market);
         if ((market !== undefined) && (market['contract'])) {
@@ -5671,6 +6387,128 @@ export default class kucoin extends Exchange {
             'trades': undefined,
         }, market);
     }
+    parseUtaOrder(order, market = undefined) {
+        //
+        // createOrder
+        //     {
+        //         "orderId": "426319129738321920",
+        //         "tradeType": "SPOT",
+        //         "ts": 1774455603216000000,
+        //         "clientOid": "b896c118-a674-4863-baf4-a9ea3cd696c5"
+        //     }
+        //
+        // fetchOrder
+        //     {
+        //         "orderId": "426319129738321920",
+        //         "symbol": "ETH-USDT",
+        //         "orderType": "LIMIT",
+        //         "side": "BUY",
+        //         "size": "0.001",
+        //         "price": "1000",
+        //         "timeInForce": "GTC",
+        //         "tags": "partner:ccxt",
+        //         "orderTime": 1774455603156417582,
+        //         "stp": "",
+        //         "cancelAfter": null,
+        //         "postOnly": false,
+        //         "reduceOnly": false,
+        //         "triggerDirection": "",
+        //         "triggerPrice": "",
+        //         "triggerPriceType": "",
+        //         "tpTriggerPrice": "",
+        //         "tpTriggerPriceType": "",
+        //         "slTriggerPrice": "",
+        //         "slTriggerPriceType": "",
+        //         "filledSize": "0",
+        //         "avgPrice": "0",
+        //         "fee": "0",
+        //         "feeCurrency": "USDT",
+        //         "tax": "0",
+        //         "updatedTime": 1774455603371523690,
+        //         "triggerOrderId": "",
+        //         "cancelReason": "",
+        //         "cancelSize": "0",
+        //         "clientOid": "b896c118-a674-4863-baf4-a9ea3cd696c5",
+        //         "sizeUnit": "BASECCY",
+        //         "tradeType": "SPOT",
+        //         "tradeId": "",
+        //         "status": 2
+        //     }
+        //
+        const marketId = this.safeString(order, 'symbol');
+        market = this.safeMarket(marketId, market);
+        const symbol = market['symbol'];
+        const timestamp = this.safeIntegerProduct2(order, 'orderTime', 'ts', 0.000001);
+        const lastUpdateTimestamp = this.safeIntegerProduct(order, 'updatedTime', 0.000001);
+        const rawTimeInForce = this.safeString(order, 'timeInForce');
+        let amount = undefined;
+        let cost = undefined;
+        const sizeUnit = this.safeString(order, 'sizeUnit');
+        const size = this.safeString(order, 'size');
+        const rawStatus = this.safeString(order, 'status');
+        const average = this.safeString(order, 'avgPrice');
+        let filled = this.safeString(order, 'filledSize'); // might be in base or quote, need to check sizeUnit
+        if ((sizeUnit === 'BASECCY') || (sizeUnit === 'UNIT')) {
+            amount = size;
+        }
+        else {
+            cost = filled;
+            filled = Precise.stringDiv(filled, average);
+            filled = this.amountToPrecision(symbol, filled);
+        }
+        const fee = {
+            'currency': this.safeCurrencyCode(this.safeString(order, 'feeCurrency')),
+            'cost': this.safeString(order, 'fee'),
+        };
+        return this.safeOrder({
+            'id': this.safeString(order, 'orderId'),
+            'clientOrderId': this.safeString(order, 'clientOid'),
+            'symbol': symbol,
+            'type': this.safeStringLower(order, 'orderType'),
+            'timeInForce': this.parseOrderTimeInForce(rawTimeInForce),
+            'postOnly': this.safeBool(order, 'postOnly'),
+            'reduceOnly': this.safeBool(order, 'reduceOnly'),
+            'side': this.safeStringLower(order, 'side'),
+            'amount': amount,
+            'price': this.safeString(order, 'price'),
+            'triggerPrice': this.safeString2(order, 'stopPrice', 'triggerPrice'),
+            'cost': cost,
+            'filled': filled,
+            'remaining': undefined,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'fee': fee,
+            'status': this.parseOrderStatus(rawStatus),
+            'lastTradeTimestamp': undefined,
+            'lastUpdateTimestamp': lastUpdateTimestamp,
+            'average': average,
+            'trades': undefined,
+            'stopLossPrice': this.safeString(order, 'slTriggerPrice'),
+            'takeProfitPrice': this.safeString(order, 'tpTriggerPrice'),
+            'info': order,
+        }, market);
+    }
+    parseOrderTimeInForce(timeInForce) {
+        const timeInForces = {
+            'GTC': 'GTC',
+            'IOC': 'IOC',
+            'FOK': 'FOK',
+            'GTT': 'GTD',
+        };
+        return this.safeString(timeInForces, timeInForce, timeInForce);
+    }
+    parseOrderStatus(status) {
+        const statuses = {
+            '0': 'open',
+            '1': 'open',
+            '2': 'open',
+            '3': 'closed',
+            '4': 'open',
+            '5': 'canceled',
+            '6': 'closed', // partial canceled
+        };
+        return this.safeString(statuses, status, status);
+    }
     /**
      * @method
      * @name kucoin#fetchOrderTrades
@@ -5678,12 +6516,14 @@ export default class kucoin extends Exchange {
      * @see https://docs.kucoin.com/#list-fills
      * @see https://www.kucoin.com/docs-new/rest/futures-trading/orders/get-trade-history
      * @see https://www.kucoin.com/docs-new/rest/margin-trading/orders/get-trade-history
+     * @see https://www.kucoin.com/docs-new/rest/ua/get-trade-history
      * @param {string} id order id
      * @param {string} symbol unified market symbol
      * @param {int} [since] the earliest time in ms to fetch trades for
      * @param {int} [limit] the maximum number of trades to retrieve
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @param {string} [params.type] 'spot' or 'swap', used if symbol is not provided (default is 'spot')
+     * @param {boolean} [params.uta] set to true if fetching trades from uta endpoint, default is false.
      * @returns {object[]} a list of [trade structures]{@link https://docs.ccxt.com/?id=trade-structure}
      */
     async fetchOrderTrades(id, symbol = undefined, since = undefined, limit = undefined, params = {}) {
@@ -5697,6 +6537,7 @@ export default class kucoin extends Exchange {
      * @name kucoin#fetchMyTrades
      * @see https://www.kucoin.com/docs-new/rest/spot-trading/orders/get-trade-history
      * @see https://www.kucoin.com/docs-new/rest/margin-trading/orders/get-trade-history
+     * @see https://www.kucoin.com/docs-new/rest/ua/get-trade-history
      * @description fetch all trades made by the user
      * @param {string} symbol unified market symbol
      * @param {int} [since] the earliest time in ms to fetch trades for
@@ -5715,6 +6556,12 @@ export default class kucoin extends Exchange {
             market = this.market(symbol);
         }
         [marketType, params] = this.handleMarketTypeAndParams('fetchMyTrades', market, params);
+        let uta = await this.isUTAEnabled();
+        [uta, params] = this.handleOptionAndParams(params, 'fetchMyTrades', 'uta', uta);
+        if (uta) {
+            params = this.extend(params, { 'marketType': marketType });
+            return await this.fetchMyUtaTrades(symbol, since, limit, params);
+        }
         if ((marketType === 'spot') || (marketType === 'margin')) {
             return await this.fetchMySpotTrades(symbol, since, limit, params);
         }
@@ -5931,57 +6778,144 @@ export default class kucoin extends Exchange {
     }
     /**
      * @method
-     * @name kucoin#fetchTrades
-     * @description get the list of most recent trades for a particular symbol
-     * @see https://www.kucoin.com/docs-new/rest/spot-trading/market-data/get-trade-history
-     * @see https://www.kucoin.com/docs-new/rest/ua/get-trades
-     * @see https://www.kucoin.com/docs-new/rest/futures-trading/market-data/get-trade-history
-     * @param {string} symbol unified symbol of the market to fetch trades for
-     * @param {int} [since] timestamp in ms of the earliest trade to fetch
-     * @param {int} [limit] the maximum amount of trades to fetch
+     * @name kucoin#fetchMyUtaTrades
+     * @see https://www.kucoin.com/docs-new/rest/ua/get-trade-history
+     * @description fetch all trades made by the user
+     * @param {string} symbol unified market symbol
+     * @param {int} [since] the earliest time in ms to fetch trades for
+     * @param {int} [limit] the maximum number of trades structures to retrieve (default is 50, max is 200)
      * @param {object} [params] extra parameters specific to the exchange API endpoint
-     * @param {boolean} [params.uta] set to true for the unified trading account (uta), defaults to false
-     * @returns {Trade[]} a list of [trade structures]{@link https://docs.ccxt.com/?id=public-trades}
+     * @param {int} [params.until] the latest time in ms to fetch entries for
+     * @param {string} [params.accountMode] 'unified' or 'classic', defaults to 'unified'
+     * @param {string} [params.marginMode] 'cross' or 'isolated', only for margin trades
+     * @param {string} [params.side] 'BUY' or 'SELL' (both if not provided)
+     * @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)
+     * @returns {Trade[]} a list of [trade structures]{@link https://docs.ccxt.com/?id=trade-structure}
      */
-    async fetchTrades(symbol, since = undefined, limit = undefined, params = {}) {
+    async fetchMyUtaTrades(symbol = undefined, since = undefined, limit = undefined, params = {}) {
         await this.loadMarkets();
-        const market = this.market(symbol);
-        const request = {
-            'symbol': market['id'],
-        };
-        // pagination is not supported on the exchange side anymore
-        // if (since !== undefined) {
-        //     request['startAt'] = Math.floor (since / 1000);
-        // }
-        // if (limit !== undefined) {
-        //     request['pageSize'] = limit;
-        // }
-        let uta = undefined;
-        [uta, params] = this.handleOptionAndParams(params, 'fetchTrades', 'uta', false);
-        let response = undefined;
-        let trades = undefined;
-        let type = undefined;
-        [type, params] = this.handleMarketTypeAndParams('fetchTrades', market, params);
-        if (uta) {
-            if ((type === 'spot') || (type === 'margin')) {
-                request['tradeType'] = 'SPOT';
-            }
-            else {
-                request['tradeType'] = 'FUTURES';
-            }
-            response = await this.utaGetMarketTrade(this.extend(request, params));
-            //
-            //     {
-            //         "code": "200000",
-            //         "data": {
-            //             "tradeType": "SPOT",
-            //             "list": [
-            //                 {
-            //                     "sequence": "18746044393340932",
-            //                     "tradeId": "18746044393340932",
-            //                     "price": "104355.6",
-            //                     "size": "0.00011886",
-            //                     "side": "sell",
+        let paginate = false;
+        [paginate, params] = this.handleOptionAndParams(params, 'fetchMyTrades', 'paginate');
+        if (paginate) {
+            return await this.fetchPaginatedCallDynamic('fetchMyTrades', symbol, since, limit, params);
+        }
+        const marketType = this.safeString(params, 'marketType');
+        if (marketType !== undefined) {
+            params = this.omit(params, 'marketType');
+        }
+        let request = {};
+        let isContract = false;
+        let market = undefined;
+        if (symbol !== undefined) {
+            market = this.market(symbol);
+            request['symbol'] = market['id'];
+            isContract = market['contract'];
+        }
+        else if ((marketType === 'spot') || (marketType === 'margin')) {
+            throw new ArgumentsRequired(this.id + ' fetchMyTrades() requires a symbol parameter for uta spot or margin trades');
+        }
+        else {
+            isContract = true;
+        }
+        let marginMode = undefined;
+        [marginMode, params] = this.handleMarginModeAndParams('fetchMyTrades', params);
+        const tradeType = this.handleTradeType(isContract, marginMode, params);
+        request['tradeType'] = tradeType;
+        let accountMode = 'unified';
+        [accountMode, params] = this.handleOptionAndParams(params, 'fetchMyTrades', 'accountMode', accountMode);
+        request['accountMode'] = accountMode;
+        if (since !== undefined) {
+            request['startAt'] = since;
+        }
+        if (limit !== undefined) {
+            request['pageSize'] = limit;
+        }
+        [request, params] = this.handleUntilOption('endAt', request, params);
+        const response = await this.utaPrivateGetAccountModeOrderExecution(this.extend(request, params));
+        //
+        //     {
+        //         "code": "200000",
+        //         "data": {
+        //             "tradeType": "FUTURES",
+        //             "lastId": 30000000000531982,
+        //             "items": [
+        //                 {
+        //                     "orderId": "426373228194254848",
+        //                     "symbol": "DOGEUSDTM",
+        //                     "orderType": "MARKET",
+        //                     "side": "BUY",
+        //                     "tradeId": "1711108516570",
+        //                     "size": "1",
+        //                     "price": "0.09641",
+        //                     "value": "9.641",
+        //                     "executionTime": 1774468501294000000,
+        //                     "fee": "0.0057846",
+        //                     "feeCurrency": "USDT",
+        //                     "tax": "",
+        //                     "liquidityRole": "TAKER",
+        //                     "fillType": "NORMAL"
+        //                 }
+        //             ]
+        //         }
+        //     }
+        //
+        const data = this.safeDict(response, 'data', {});
+        const trades = this.safeList(data, 'items', []);
+        return this.parseTrades(trades, market, since, limit);
+    }
+    /**
+     * @method
+     * @name kucoin#fetchTrades
+     * @description get the list of most recent trades for a particular symbol
+     * @see https://www.kucoin.com/docs-new/rest/spot-trading/market-data/get-trade-history
+     * @see https://www.kucoin.com/docs-new/rest/ua/get-trades
+     * @see https://www.kucoin.com/docs-new/rest/futures-trading/market-data/get-trade-history
+     * @param {string} symbol unified symbol of the market to fetch trades for
+     * @param {int} [since] timestamp in ms of the earliest trade to fetch
+     * @param {int} [limit] the maximum amount of trades to fetch
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {boolean} [params.uta] set to true for the unified trading account (uta), defaults to false
+     * @returns {Trade[]} a list of [trade structures]{@link https://docs.ccxt.com/?id=public-trades}
+     */
+    async fetchTrades(symbol, since = undefined, limit = undefined, params = {}) {
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const request = {
+            'symbol': market['id'],
+        };
+        // pagination is not supported on the exchange side anymore
+        // if (since !== undefined) {
+        //     request['startAt'] = Math.floor (since / 1000);
+        // }
+        // if (limit !== undefined) {
+        //     request['pageSize'] = limit;
+        // }
+        let uta = false;
+        [uta, params] = this.handleOptionAndParams(params, 'fetchTrades', 'uta', uta);
+        let response = undefined;
+        let trades = undefined;
+        let type = undefined;
+        [type, params] = this.handleMarketTypeAndParams('fetchTrades', market, params);
+        if (uta) {
+            if ((type === 'spot') || (type === 'margin')) {
+                request['tradeType'] = 'SPOT';
+            }
+            else {
+                request['tradeType'] = 'FUTURES';
+            }
+            response = await this.utaGetMarketTrade(this.extend(request, params));
+            //
+            //     {
+            //         "code": "200000",
+            //         "data": {
+            //             "tradeType": "SPOT",
+            //             "list": [
+            //                 {
+            //                     "sequence": "18746044393340932",
+            //                     "tradeId": "18746044393340932",
+            //                     "price": "104355.6",
+            //                     "size": "0.00011886",
+            //                     "side": "sell",
             //                     "ts": 1762242540829000000
             //                 },
             //             ]
@@ -6033,6 +6967,9 @@ export default class kucoin extends Exchange {
         return this.parseTrades(trades, market, since, limit);
     }
     parseTrade(trade, market = undefined) {
+        if ('liquidityRole' in trade) { // property specific to myTrades from uta endpoint
+            return this.parseMyUtaTrade(trade, market);
+        }
         const marketId = this.safeString(trade, 'symbol');
         market = this.safeMarket(marketId, market);
         if ((market === undefined) || (market['spot'])) {
@@ -6319,23 +7256,97 @@ export default class kucoin extends Exchange {
             'fee': fee,
         }, market);
     }
+    parseMyUtaTrade(trade, market = undefined) {
+        //
+        //     {
+        //         "orderId": "426373228194254848",
+        //         "symbol": "DOGEUSDTM",
+        //         "orderType": "MARKET",
+        //         "side": "BUY",
+        //         "tradeId": "1711108516570",
+        //         "size": "1",
+        //         "price": "0.09641",
+        //         "value": "9.641",
+        //         "executionTime": 1774468501294000000,
+        //         "fee": "0.0057846",
+        //         "feeCurrency": "USDT",
+        //         "tax": "",
+        //         "liquidityRole": "TAKER",
+        //         "fillType": "NORMAL"
+        //     }
+        //
+        const marketId = this.safeString(trade, 'symbol');
+        market = this.safeMarket(marketId, market);
+        const timestamp = this.safeIntegerProduct(trade, 'executionTime', 0.000001);
+        const fee = {
+            'cost': this.safeString(trade, 'fee'),
+            'currency': this.safeCurrencyCode(this.safeString(trade, 'feeCurrency')),
+        };
+        return this.safeTrade({
+            'info': trade,
+            'id': this.safeString(trade, 'tradeId'),
+            'order': this.safeString(trade, 'orderId'),
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'symbol': market['symbol'],
+            'type': this.safeStringLower(trade, 'orderType'),
+            'takerOrMaker': this.safeStringLower(trade, 'liquidityRole'),
+            'side': this.safeStringLower(trade, 'side'),
+            'price': this.safeString(trade, 'price'),
+            'amount': this.safeString(trade, 'size'),
+            'cost': this.safeString(trade, 'value'),
+            'fee': fee,
+        }, market);
+    }
     /**
      * @method
      * @name kucoin#fetchTradingFee
      * @description fetch the trading fees for a market
      * @see https://www.kucoin.com/docs-new/rest/account-info/trade-fee/get-actual-fee-spot-margin
      * @see https://www.kucoin.com/docs-new/rest/account-info/trade-fee/get-actual-fee-futures
+     * @see https://www.kucoin.com/docs-new/rest/ua/get-actual-fee
      * @param {string} symbol unified market symbol
      * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {boolean} [params.uta] set to true for the unified trading account (uta) endpoint, defaults to false
      * @returns {object} a [fee structure]{@link https://docs.ccxt.com/?id=fee-structure}
      */
     async fetchTradingFee(symbol, params = {}) {
         await this.loadMarkets();
         const market = this.market(symbol);
+        let uta = await this.isUTAEnabled();
+        [uta, params] = this.handleOptionAndParams(params, 'fetchTradingFee', 'uta', uta);
         const request = {};
         let response = undefined;
         let entry = undefined;
-        if (market['spot']) {
+        if (uta) {
+            if (market['spot']) {
+                request['tradeType'] = 'SPOT';
+            }
+            else {
+                request['tradeType'] = 'FUTURES';
+            }
+            request['symbol'] = market['id'];
+            response = await this.utaPrivateGetUserFeeRate(this.extend(request, params));
+            //
+            //     {
+            //         "code": "200000",
+            //         "data": {
+            //             "tradeType": "SPOT",
+            //             "list": [
+            //                 {
+            //                     "symbol": "ETH-USDT",
+            //                     "takerFeeRate": "0.001",
+            //                     "makerFeeRate": "0.001"
+            //                 }
+            //             ]
+            //         }
+            //     }
+            //
+            const data = this.safeDict(response, 'data', {});
+            const dataList = this.safeList(data, 'list', []);
+            entry = this.safeDict(dataList, 0);
+        }
+        else if (market['spot']) {
             request['symbols'] = market['id'];
             response = await this.privateGetTradeFees(this.extend(request, params));
             //
@@ -6411,7 +7422,7 @@ export default class kucoin extends Exchange {
         let networkCode = undefined;
         [networkCode, params] = this.handleNetworkCodeAndParams(params);
         if (networkCode !== undefined) {
-            request['chain'] = this.networkCodeToId(networkCode).toLowerCase();
+            request['chain'] = this.networkCodeToId(networkCode, currency['code']).toLowerCase();
         }
         request['amount'] = parseFloat(this.currencyToPrecision(code, amount, networkCode));
         let includeFee = undefined;
@@ -6532,12 +7543,13 @@ export default class kucoin extends Exchange {
         }
         const internal = this.safeBool(transaction, 'isInner');
         const tag = this.safeString(transaction, 'memo');
+        const chainId = this.safeString(transaction, 'chain');
         return {
             'info': transaction,
             'id': this.safeString2(transaction, 'id', 'withdrawalId'),
             'timestamp': timestamp,
             'datetime': this.iso8601(timestamp),
-            'network': this.networkIdToCode(this.safeString(transaction, 'chain')),
+            'network': this.networkIdToCode(chainId, code),
             'address': address,
             'addressTo': address,
             'addressFrom': undefined,
@@ -6729,10 +7741,11 @@ export default class kucoin extends Exchange {
         if (accountType === 'contract') {
             return await this.fetchContractWithdrawals(code, since, limit, params);
         }
+        const maxLimit = 500;
         let paginate = false;
         [paginate, params] = this.handleOptionAndParams(params, 'fetchWithdrawals', 'paginate');
         if (paginate) {
-            return await this.fetchPaginatedCallDynamic('fetchWithdrawals', code, since, limit, params);
+            return await this.fetchPaginatedCallDynamic('fetchWithdrawals', code, since, limit, params, maxLimit);
         }
         let request = {};
         let currency = undefined;
@@ -6872,14 +7885,24 @@ export default class kucoin extends Exchange {
      * @see https://www.kucoin.com/docs-new/rest/account-info/account-funding/get-account-cross-margin
      * @see https://www.kucoin.com/docs-new/rest/account-info/account-funding/get-account-isolated-margin
      * @see https://www.kucoin.com/docs-new/rest/account-info/account-funding/get-account-futures
+     * @see https://www.kucoin.com/docs-new/rest/ua/get-account-currency-assets-uta
+     * @see https://www.kucoin.com/docs-new/rest/ua/get-account-currency-assets-classic
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @param {object} [params.marginMode] 'cross' or 'isolated', margin type for fetching margin balance
      * @param {object} [params.type] extra parameters specific to the exchange API endpoint
      * @param {object} [params.hf] *default if false* if true, the result includes the balance of the high frequency account
+     * @param {boolean} [params.uta] set to true for the unified trading account (uta) endpoint, defaults to false
      * @returns {object} a [balance structure]{@link https://docs.ccxt.com/?id=balance-structure}
      */
     async fetchBalance(params = {}) {
         await this.loadMarkets();
+        let uta = await this.isUTAEnabled();
+        [uta, params] = this.handleOptionAndParams(params, 'fetchBalance', 'uta', uta);
+        if (uta) {
+            return await this.fetchUtaBalance(params);
+        }
+        let response = undefined;
+        const request = {};
         const code = this.safeString(params, 'code');
         let currency = undefined;
         if (code !== undefined) {
@@ -6898,26 +7921,25 @@ export default class kucoin extends Exchange {
         if (hf && (type !== 'main')) {
             type = 'trade_hf';
         }
-        const [marginMode, query] = this.handleMarginModeAndParams('fetchBalance', params);
-        let response = undefined;
-        const request = {};
+        let marginMode = undefined;
+        [marginMode, params] = this.handleMarginModeAndParams('fetchBalance', params);
         const isolated = (marginMode === 'isolated') || (type === 'isolated');
         const cross = (marginMode === 'cross') || (type === 'margin');
         if (isolated) {
             if (currency !== undefined) {
                 request['balanceCurrency'] = currency['id'];
             }
-            response = await this.privateGetIsolatedAccounts(this.extend(request, query));
+            response = await this.privateGetIsolatedAccounts(this.extend(request, params));
         }
         else if (cross) {
-            response = await this.privateGetMarginAccount(this.extend(request, query));
+            response = await this.privateGetMarginAccount(this.extend(request, params));
         }
         else {
             if (currency !== undefined) {
                 request['currency'] = currency['id'];
             }
             request['type'] = type;
-            response = await this.privateGetAccounts(this.extend(request, query));
+            response = await this.privateGetAccounts(this.extend(request, params));
         }
         //
         // Spot
@@ -7101,11 +8123,260 @@ export default class kucoin extends Exchange {
         result[currencyCode] = account;
         return this.safeBalance(result);
     }
+    /**
+     * @method
+     * @name kucoin#fetchUtaBalance
+     * @description helper method for fetching balance with unified trading account (uta) endpoint
+     * @see https://www.kucoin.com/docs-new/rest/ua/get-account-currency-assets-uta
+     * @see https://www.kucoin.com/docs-new/rest/ua/get-account-currency-assets-classic
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {string} [params.type] 'spot', 'unified', 'funding', 'cross', 'isolated' or 'swap' (default is 'spot')
+     * @param {string} [params.marginMode] 'cross' or 'isolated', margin type for fetching margin balance, only applicable if type is margin (default is cross)
+     * @returns {object} a [balance structure]{@link https://docs.ccxt.com/?id=balance-structure}
+     */
+    async fetchUtaBalance(params = {}) {
+        await this.loadMarkets();
+        let requestedType = undefined;
+        [requestedType, params] = this.handleMarketTypeAndParams('fetchUtaBalance', undefined, params);
+        if (requestedType === 'margin') {
+            // assume cross margin if margin is specified but marginMode is not specified
+            let marginMode = 'cross';
+            [marginMode, params] = this.handleMarginModeAndParams('fetchUtaBalance', params, marginMode);
+            requestedType = marginMode;
+        }
+        const utaAccountsByType = this.safeDict(this.options, 'utaAccountsByType', {});
+        let type = undefined;
+        type = this.safeString(utaAccountsByType, requestedType, type);
+        const isIsolated = (type === 'ISOLATED');
+        const request = {};
+        let response = undefined;
+        if (type === 'unified') {
+            request['accountMode'] = type;
+            // uta
+            //     {
+            //         "code": "200000",
+            //         "data": {
+            //             "accountType": "UNIFIED",
+            //             "ts": 1764731696945,
+            //             "accounts": [
+            //                 {
+            //                     "currencies": [
+            //                         {
+            //                             "currency": "USDT",
+            //                             "equity": "97.9936711985",
+            //                             "hold": "0.0000000000",
+            //                             "balance": "97.9936711985",
+            //                             "available": "97.9936711985",
+            //                             "liability": "0.0000000000"
+            //                         },
+            //                         {
+            //                             "currency": "BTC",
+            //                             "equity": "0.0000216000",
+            //                             "hold": "0.0000000000",
+            //                             "balance": "0.0000216000",
+            //                             "available": "0.0000216000",
+            //                             "liability": "0.0000000000"
+            //                         }
+            //                     ]
+            //                 }
+            //             ]
+            //         }
+            //     }
+            //
+            response = await this.utaPrivateGetAccountModeAccountBalance(this.extend(request, params));
+        }
+        else {
+            request['accountType'] = type;
+            //
+            // isolated
+            //     {
+            //         "code": "200000",
+            //         "data": {
+            //             "accountType": "ISOLATED",
+            //             "ts": 1774244660519,
+            //             "accounts": [
+            //                 {
+            //                     "accountSubtype": "LTC-USDT",
+            //                     "riskRatio": "0",
+            //                     "currencies": [
+            //                         {
+            //                             "currency": "LTC",
+            //                             "hold": "0",
+            //                             "available": "0",
+            //                             "liability": "0",
+            //                             "balance": "0",
+            //                             "equity": "0"},{
+            //                             "currency": "USDT",
+            //                             "hold": "0",
+            //                             "available": "6",
+            //                             "liability": "0",
+            //                             "balance": "6",
+            //                             "equity": "6"
+            //                         }
+            //                     ]
+            //                 }
+            //             ]
+            //         }
+            //     }
+            //
+            response = await this.utaPrivateGetAccountBalance(this.extend(request, params));
+        }
+        const data = this.safeDict(response, 'data', {});
+        const timestamp = this.safeInteger(data, 'ts');
+        const result = {
+            'info': response,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+        };
+        const accounts = this.safeList(data, 'accounts', []);
+        if (isIsolated) {
+            for (let i = 0; i < accounts.length; i++) {
+                const entry = accounts[i];
+                const marketId = this.safeString(entry, 'accountSubtype');
+                const symbol = this.safeSymbol(marketId, undefined, '-');
+                const subResult = {};
+                const currencies = this.safeList(entry, 'currencies', []);
+                for (let j = 0; j < currencies.length; j++) {
+                    const currencyEntry = this.safeDict(currencies, j, {});
+                    const currencyId = this.safeString(currencyEntry, 'currency');
+                    const currencyCode = this.safeCurrencyCode(currencyId);
+                    subResult[currencyCode] = this.parseBalanceHelper(currencyEntry);
+                }
+                result[symbol] = this.safeBalance(subResult);
+            }
+        }
+        else {
+            const firstAccount = this.safeDict(accounts, 0, {});
+            const currencies = this.safeList(firstAccount, 'currencies', []);
+            for (let i = 0; i < currencies.length; i++) {
+                const currencyEntry = this.safeDict(currencies, i, {});
+                const currencyId = this.safeString(currencyEntry, 'currency');
+                const currencyCode = this.safeCurrencyCode(currencyId);
+                result[currencyCode] = this.parseBalanceHelper(currencyEntry);
+            }
+        }
+        let returnType = result;
+        if (!isIsolated) {
+            returnType = this.safeBalance(result);
+        }
+        return returnType;
+    }
     /**
      * @method
      * @name kucoin#transfer
      * @description transfer currency internally between wallets on the same account
      * @see https://www.kucoin.com/docs-new/rest/account-info/transfer/flex-transfer?lang=en_US&
+     * @see https://www.kucoin.com/docs-new/rest/ua/flex-transfer
+     * @param {string} code unified currency code
+     * @param {float} amount amount to transfer
+     * @param {string} fromAccount account to transfer from
+     * @param {string} toAccount account to transfer to
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {boolean} [params.uta] set to true for the unified trading account (uta) endpoint, defaults to false
+     * Check transferClassic() and transferUta() for more details on params
+     * @returns {object} a [transfer structure]{@link https://docs.ccxt.com/?id=transfer-structure}
+     */
+    async transfer(code, amount, fromAccount, toAccount, params = {}) {
+        await this.loadMarkets();
+        let uta = await this.isUTAEnabled();
+        [uta, params] = this.handleOptionAndParams(params, 'transfer', 'uta', uta);
+        if (uta) {
+            return await this.transferUta(code, amount, fromAccount, toAccount, params);
+        }
+        return await this.transferClassic(code, amount, fromAccount, toAccount, params);
+    }
+    /**
+     * @method
+     * @name kucoin#transferUta
+     * @description transfer currency internally between wallets on the same account with uta endpoint
+     * @see https://www.kucoin.com/docs-new/rest/ua/flex-transfer
+     * @param {string} code unified currency code
+     * @param {float} amount amount to transfer
+     * @param {string} fromAccount account to transfer from
+     * @param {string} toAccount account to transfer to
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {string} [params.transferType] INTERNAL, PARENT_TO_SUB, SUB_TO_PARENT, SUB_TO_SUB (default is INTERNAL)
+     * @param {string} [params.fromUserId] required if transferType is SUB_TO_PARENT or SUB_TO_SUB
+     * @param {string} [params.toUserId] required if transferType is PARENT_TO_SUB or SUB_TO_SUB
+     * @returns {object} a [transfer structure]{@link https://docs.ccxt.com/?id=transfer-structure}
+     */
+    async transferUta(code, amount, fromAccount, toAccount, params = {}) {
+        await this.loadMarkets();
+        const currency = this.currency(code);
+        const requestedAmount = this.currencyToPrecision(code, amount);
+        const request = {
+            'currency': currency['id'],
+            'amount': requestedAmount,
+        };
+        let transferType = 'INTERNAL';
+        [transferType, params] = this.handleParamString2(params, 'transferType', 'type', transferType);
+        let fromUserId = undefined;
+        [fromUserId, params] = this.handleParamString2(params, 'fromUserId', 'fromUid', fromUserId);
+        let toUserId = undefined;
+        [toUserId, params] = this.handleParamString2(params, 'toUserId', 'toUid', toUserId);
+        if (transferType === 'PARENT_TO_SUB' || transferType === 'SUB_TO_SUB') {
+            if (toUserId === undefined) {
+                throw new ExchangeError(this.id + ' transfer() requires a toUserId param for PARENT_TO_SUB or SUB_TO_SUB transfers');
+            }
+            else {
+                request['toUid'] = toUserId;
+            }
+        }
+        else if (transferType === 'SUB_TO_PARENT' || transferType === 'SUB_TO_SUB') {
+            if (fromUserId === undefined) {
+                throw new ExchangeError(this.id + ' transfer() requires a fromUserId param for SUB_TO_PARENT or SUB_TO_SUB transfers');
+            }
+            else {
+                request['fromUid'] = fromUserId;
+            }
+        }
+        let clientOid = this.uuid();
+        [clientOid, params] = this.handleParamString2(params, 'clientOid', 'clientOrderId', clientOid);
+        request['clientOid'] = clientOid;
+        let fromId = this.convertTypeToAccount(fromAccount);
+        let toId = this.convertTypeToAccount(toAccount);
+        const fromIsolated = this.inArray(fromId, this.ids);
+        const toIsolated = this.inArray(toId, this.ids);
+        if (fromIsolated) {
+            request['fromAccountSymbol'] = fromId;
+            fromId = 'ISOLATED';
+        }
+        if (toIsolated) {
+            request['toAccountSymbol'] = toId;
+            toId = 'ISOLATED';
+        }
+        const utaAccountsByType = this.safeDict(this.options, 'utaAccountsByType', {});
+        fromId = this.safeString(utaAccountsByType, fromId, fromId);
+        toId = this.safeString(utaAccountsByType, toId, toId);
+        request['fromAccountType'] = fromId.toUpperCase();
+        request['toAccountType'] = toId.toUpperCase();
+        const types = {
+            'INTERNAL': '0',
+            'PARENT_TO_SUB': '1',
+            'SUB_TO_PARENT': '2',
+            'SUB_TO_SUB': '3',
+        };
+        request['type'] = this.safeString(types, transferType, transferType);
+        const response = await this.utaPrivatePostAccountTransfer(this.extend(request, params));
+        //
+        //
+        const data = this.safeDict(response, 'data');
+        const transfer = this.parseTransfer(data, currency);
+        const transferOptions = this.safeDict(this.options, 'transfer', {});
+        const fillResponseFromRequest = this.safeBool(transferOptions, 'fillResponseFromRequest', true);
+        if (fillResponseFromRequest) {
+            transfer['amount'] = amount;
+            transfer['fromAccount'] = fromAccount;
+            transfer['toAccount'] = toAccount;
+            transfer['status'] = 'ok';
+        }
+        return transfer;
+    }
+    /**
+     * @method
+     * @name kucoin#transferClassic
+     * @description transfer currency internally between wallets on the same account with classic endpoints
+     * @see https://www.kucoin.com/docs-new/rest/account-info/transfer/flex-transfer?lang=en_US&
      * @param {string} code unified currency code
      * @param {float} amount amount to transfer
      * @param {string} fromAccount account to transfer from
@@ -7116,7 +8387,7 @@ export default class kucoin extends Exchange {
      * @param {string} [params.toUserId] required if transferType is PARENT_TO_SUB
      * @returns {object} a [transfer structure]{@link https://docs.ccxt.com/?id=transfer-structure}
      */
-    async transfer(code, amount, fromAccount, toAccount, params = {}) {
+    async transferClassic(code, amount, fromAccount, toAccount, params = {}) {
         await this.loadMarkets();
         const currency = this.currency(code);
         const requestedAmount = this.currencyToPrecision(code, amount);
@@ -7330,12 +8601,32 @@ export default class kucoin extends Exchange {
             // 'Pool transactions': 'Pool transactions', // Pool-X transactions
             'Instant Exchange': 'trade',
             'Sub-account transfer': 'transfer',
-            'Liquidation Fees': 'fee', // Liquidation Fees
+            'Liquidation Fees': 'fee',
             // 'Soft Staking Profits': 'Soft Staking Profits', // Soft Staking Profits
             // 'Voting Earnings': 'Voting Earnings', // Voting Earnings on Pool-X
             // 'Redemption of Voting': 'Redemption of Voting', // Redemption of Voting on Pool-X
             // 'Voting': 'Voting', // Voting on Pool-X
             // 'Convert to KCS': 'Convert to KCS', // Convert to KCS
+            'RealisedPNL': 'trade',
+            'TransferIn': 'transfer',
+            'TransferOut': 'transfer',
+            'TRADE_EXCHANGE': 'trade',
+            'TRANSFER': 'transfer',
+            'SUB_TRANSFER': 'transfer',
+            'RETURNED_FEES': 'fee',
+            'DEDUCTION_FEES': 'fee',
+            'OTHER': 'other',
+            'SUB_TO_SUB_TRANSFER': 'transfer',
+            'SPOT_EXCHANGE': 'trade',
+            'SPOT_EXCHANGE_REBATE': 'rebate',
+            'FUTURES_EXCHANGE_OPEN': 'trade',
+            'FUTURES_EXCHANGE_CLOSE': 'trade',
+            'FUTURES_EXCHANGE_REBATE': 'rebate',
+            'FUNDING_FEE': 'fee',
+            'LIABILITY_INTEREST': 'fee',
+            'KCS_DEDUCTION_FEES': 'fee',
+            'KCS_RETURNED_FEES': 'fee',
+            'AUTO_EXCHANGE_USER': 'trade',
         };
         return this.safeString(types, type, type);
     }
@@ -7345,6 +8636,8 @@ export default class kucoin extends Exchange {
             'out': 'out',
             'TransferIn': 'in',
             'TransferOut': 'out',
+            'IN': 'in',
+            'OUT': 'out',
         };
         return this.safeString(directions, direction, direction);
     }
@@ -7383,14 +8676,28 @@ export default class kucoin extends Exchange {
         //         "currency": "USDT"
         //     }
         //
+        // ledger entry from UTA API
+        //     {
+        //         "accountType": "UNIFIED",
+        //         "id": "30000000001200350",
+        //         "currency": "USDT",
+        //         "direction": "IN",
+        //         "businessType": "TRANSFER",
+        //         "amount": "30",
+        //         "balance": "30",
+        //         "fee": "0",
+        //         "tax": "0",
+        //         "remark": "Funding Account",
+        //         "ts": 1774241648267000000
+        //     }
+        //
         const id = this.safeString(item, 'id');
         const currencyId = this.safeString(item, 'currency');
         const code = this.safeCurrencyCode(currencyId, currency);
         currency = this.safeCurrency(currencyId, currency);
         const amount = this.safeString(item, 'amount');
-        const balanceAfter = undefined;
-        // const balanceAfter = this.safeNumber (item, 'balance'); only returns zero string
-        const bizType = this.safeString(item, 'bizType');
+        const balanceAfter = this.safeNumberOmitZero(item, 'balance');
+        const bizType = this.safeStringN(item, ['bizType', 'businessType', 'type']);
         const type = this.parseLedgerEntryType(bizType);
         const direction = this.safeString2(item, 'direction', 'type');
         let account = this.safeString(item, 'accountType'); // MAIN, TRADE, MARGIN, or CONTRACT
@@ -7400,6 +8707,9 @@ export default class kucoin extends Exchange {
             if (timestamp !== undefined) {
                 account = 'CONTRACT'; // contract ledger entries do not have an accountType field, so we set it to CONTRACT if the time field is present
             }
+            else {
+                timestamp = this.safeIntegerProduct(item, 'ts', 0.000001); // for UTA API
+            }
         }
         const datetime = this.iso8601(timestamp);
         const context = this.safeString(item, 'context'); // contains other information about the ledger entry
@@ -7468,6 +8778,7 @@ export default class kucoin extends Exchange {
      * @see https://www.kucoin.com/docs-new/rest/account-info/account-funding/get-account-ledgers-tradehf
      * @see https://www.kucoin.com/docs-new/rest/account-info/account-funding/get-account-ledgers-marginhf
      * @see https://www.kucoin.com/docs-new/rest/account-info/account-funding/get-account-ledgers-futures
+     * @see https://www.kucoin.com/docs-new/rest/ua/get-account-ledger
      * @param {string} [code] unified currency code, default is undefined
      * @param {int} [since] timestamp in ms of the earliest ledger entry, default is undefined
      * @param {int} [limit] max number of ledger entries to return, default is undefined
@@ -7475,18 +8786,50 @@ export default class kucoin extends Exchange {
      * @param {object} [params.type] extra parameters specific to the exchange API endpoint
      * @param {boolean} [params.hf] default false, when true will fetch ledger entries for the high frequency trading account
      * @param {int} [params.until] the latest time in ms to fetch entries for
+     * @param {boolean} [params.uta] default false, when true will fetch ledger entries for the unified trading account (UTA) instead of the regular accounts endpoint
      * @param {boolean} [params.paginate] default false, when true will automatically paginate by calling this endpoint multiple times. See in the docs all the [available parameters](https://github.com/ccxt/ccxt/wiki/Manual#pagination-params)
      * @returns {object} a [ledger structure]{@link https://docs.ccxt.com/?id=ledger-entry-structure}
      */
     async fetchLedger(code = undefined, since = undefined, limit = undefined, params = {}) {
         await this.loadMarkets();
         await this.loadAccounts();
-        let paginate = false;
-        [paginate, params] = this.handleOptionAndParams(params, 'fetchLedger', 'paginate');
+        let uta = await this.isUTAEnabled();
+        [uta, params] = this.handleOptionAndParams(params, 'fetchLedger', 'uta', uta);
         let hf = undefined;
         [hf, params] = this.handleHfAndParams(params);
+        let requestedType = undefined;
+        [requestedType, params] = this.handleMarketTypeAndParams('fetchLedger', undefined, params);
+        let marginMode = undefined;
+        [marginMode, params] = this.handleMarginModeAndParams('fetchLedger', params);
+        if (uta && (requestedType === 'margin')) {
+            marginMode = (marginMode === undefined) ? 'cross' : marginMode; // default to cross margin for UTA if margin is requested but marginMode is not specified
+            requestedType = marginMode;
+        }
+        let accountsByType = this.safeDict(this.options, 'accountsByType');
+        if (uta) {
+            accountsByType = this.safeDict(this.options, 'utaAccountsByType');
+        }
+        let type = undefined;
+        type = this.safeString(accountsByType, requestedType, requestedType);
+        let maxLimit = 500; // for spot non-uta and margin
+        if (hf) {
+            maxLimit = 200;
+        }
+        else if (type === 'contract') {
+            maxLimit = 50;
+        }
+        else if (uta) {
+            if ((type === 'UNIFIED') || (type === 'SPOT')) {
+                maxLimit = 200;
+            }
+            else if (type === 'FUTURES') {
+                maxLimit = 100;
+            }
+        }
+        let paginate = false;
+        [paginate, params] = this.handleOptionAndParams(params, 'fetchLedger', 'paginate');
         if (paginate) {
-            return await this.fetchPaginatedCallDynamic('fetchLedger', code, since, limit, params);
+            return await this.fetchPaginatedCallDynamic('fetchLedger', code, since, limit, params, maxLimit);
         }
         let request = {
         // 'currency': currency['id'], // can choose up to 10, if not provided returns for all currencies by default
@@ -7505,14 +8848,23 @@ export default class kucoin extends Exchange {
             request['currency'] = currency['id'];
         }
         [request, params] = this.handleUntilOption('endAt', request, params);
-        let marginMode = undefined;
-        [marginMode, params] = this.handleMarginModeAndParams('fetchLedger', params);
-        let type = undefined;
-        [type, params] = this.handleMarketTypeAndParams('fetchLedger', undefined, params);
-        const accountsByType = this.safeDict(this.options, 'accountsByType');
-        type = this.safeString(accountsByType, type, type);
+        if (limit !== undefined) {
+            if (type === 'contract') {
+                request['maxCount'] = limit;
+            }
+            else if (hf) {
+                request['limit'] = limit;
+            }
+            else {
+                request['pageSize'] = limit;
+            }
+        }
         let response = undefined;
-        if (hf) {
+        if (uta) {
+            request['accountType'] = type;
+            response = await this.utaPrivateGetAccountLedger(this.extend(request, params));
+        }
+        else if (hf) {
             if (marginMode !== undefined) {
                 response = await this.privateGetHfMarginAccountLedgers(this.extend(request, params));
             }
@@ -7754,12 +9106,14 @@ export default class kucoin extends Exchange {
         // Cross
         //
         //     {
-        //         "currency": "1INCH",
-        //         "total": "0",
-        //         "available": "0",
+        //         "currency": "DOGE",
+        //         "total": "119.99995308",
+        //         "available": "119.99995308",
         //         "hold": "0",
-        //         "liability": "0",
-        //         "maxBorrowSize": "0",
+        //         "liability": "10.00004692",
+        //         "liabilityPrincipal": "10",
+        //         "liabilityInterest": "0.00004692",
+        //         "maxBorrowSize": "1140",
         //         "borrowEnabled": true,
         //         "transferInEnabled": true
         //     }
@@ -7767,30 +9121,32 @@ export default class kucoin extends Exchange {
         // Isolated
         //
         //     {
-        //         "symbol": "MANA-USDT",
-        //         "debtRatio": "0",
-        //         "status": "BORROW",
+        //         "symbol": "DOGE-USDT",
+        //         "status": "EFFECTIVE",
+        //         "debtRatio": "0.0822",
         //         "baseAsset": {
-        //             "currency": "MANA",
+        //             "currency": "DOGE",
         //             "borrowEnabled": true,
-        //             "repayEnabled": true,
-        //             "transferEnabled": true,
-        //             "borrowed": "0",
-        //             "totalAsset": "0",
-        //             "available": "0",
+        //             "transferInEnabled": true,
+        //             "liability": "10.00009385",
+        //             "liabilityPrincipal": "10.00004692",
+        //             "liabilityInterest": "0.00004693",
+        //             "total": "10",
+        //             "available": "10",
         //             "hold": "0",
-        //             "maxBorrowSize": "1000"
+        //             "maxBorrowSize": "990"
         //         },
         //         "quoteAsset": {
         //             "currency": "USDT",
         //             "borrowEnabled": true,
-        //             "repayEnabled": true,
-        //             "transferEnabled": true,
-        //             "borrowed": "0",
-        //             "totalAsset": "0",
-        //             "available": "0",
+        //             "transferInEnabled": true,
+        //             "liability": "0",
+        //             "liabilityPrincipal": "0",
+        //             "liabilityInterest": "0",
+        //             "total": "10",
+        //             "available": "10",
         //             "hold": "0",
-        //             "maxBorrowSize": "50000"
+        //             "maxBorrowSize": "89"
         //         }
         //     }
         //
@@ -7798,19 +9154,18 @@ export default class kucoin extends Exchange {
         const marginMode = (marketId === undefined) ? 'cross' : 'isolated';
         market = this.safeMarket(marketId, market);
         const symbol = this.safeString(market, 'symbol');
-        const timestamp = this.safeInteger(info, 'createdAt');
         const isolatedBase = this.safeDict(info, 'baseAsset', {});
         let amountBorrowed = undefined;
         let interest = undefined;
         let currencyId = undefined;
         if (marginMode === 'isolated') {
-            amountBorrowed = this.safeNumber(isolatedBase, 'liability');
-            interest = this.safeNumber(isolatedBase, 'interest');
+            amountBorrowed = this.safeNumber(isolatedBase, 'liabilityPrincipal');
+            interest = this.safeNumber(isolatedBase, 'liabilityInterest');
             currencyId = this.safeString(isolatedBase, 'currency');
         }
         else {
-            amountBorrowed = this.safeNumber(info, 'liability');
-            interest = this.safeNumber(info, 'accruedInterest');
+            amountBorrowed = this.safeNumber(info, 'liabilityPrincipal');
+            interest = this.safeNumber(info, 'liabilityInterest');
             currencyId = this.safeString(info, 'currency');
         }
         return {
@@ -7821,8 +9176,8 @@ export default class kucoin extends Exchange {
             'interestRate': this.safeNumber(info, 'dailyIntRate'),
             'amountBorrowed': amountBorrowed,
             'marginMode': marginMode,
-            'timestamp': timestamp,
-            'datetime': this.iso8601(timestamp),
+            'timestamp': undefined,
+            'datetime': undefined,
         };
     }
     /**
@@ -8205,9 +9560,11 @@ export default class kucoin extends Exchange {
      * @description set the level of leverage for a market
      * @see https://www.kucoin.com/docs-new/rest/margin-trading/debit/modify-leverage
      * @see https://www.kucoin.com/docs-new/rest/futures-trading/positions/modify-cross-margin-leverage
+     * @see https://www.kucoin.com/docs-new/rest/ua/modify-leverage-uta
      * @param {int } [leverage] New leverage multiplier. Must be greater than 1 and up to two decimal places, and cannot be less than the user's current debt leverage or greater than the system's maximum leverage
      * @param {string} [symbol] unified market symbol
      * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {boolean} [params.uta] *contract markets only* set to true for the unified trading account (uta)
      * @returns {object} response from the exchange
      */
     async setLeverage(leverage, symbol = undefined, params = {}) {
@@ -8216,11 +9573,19 @@ export default class kucoin extends Exchange {
         let marketType = undefined;
         [marketType, params] = this.handleMarketTypeAndParams('setLeverage', undefined, params);
         if ((symbol !== undefined) || ((marketType !== 'spot') && (marketType !== 'margin'))) {
+            if (symbol === undefined) {
+                throw new ArgumentsRequired(this.id + ' setLeverage requires a symbol argument for contract markets');
+            }
             market = this.market(symbol);
             if (market['contract']) {
                 return await this.setContractLeverage(leverage, symbol, params);
             }
         }
+        let uta = await this.isUTAEnabled();
+        [uta, params] = this.handleOptionAndParams(params, 'setLeverage', 'uta', uta);
+        if (uta) {
+            throw new NotSupported(this.id + ' setLeverage with params["uta"] is supported for contract markets only');
+        }
         let marginMode = undefined;
         [marginMode, params] = this.handleMarginModeAndParams('setLeverage', params);
         if (marginMode === undefined) {
@@ -8242,15 +9607,17 @@ export default class kucoin extends Exchange {
      * @name kucoin#setContractLeverage
      * @description set the level of leverage for a market
      * @see https://www.kucoin.com/docs-new/rest/futures-trading/positions/modify-cross-margin-leverage
+     * @see https://www.kucoin.com/docs-new/rest/ua/modify-leverage-uta
      * @param {float} leverage the rate of leverage
      * @param {string} symbol unified market symbol
      * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {boolean} [params.uta] set to true for the unified trading account (uta)
      * @returns {object} response from the exchange
      */
     async setContractLeverage(leverage, symbol = undefined, params = {}) {
         let marginMode = undefined;
         [marginMode, params] = this.handleMarginModeAndParams(symbol, params);
-        if (marginMode !== 'cross') {
+        if ((marginMode !== undefined) && (marginMode !== 'cross')) {
             throw new NotSupported(this.id + ' setLeverage() currently supports only params["marginMode"] = "cross" for contracts');
         }
         await this.loadMarkets();
@@ -8259,14 +9626,24 @@ export default class kucoin extends Exchange {
             'symbol': market['id'],
             'leverage': leverage.toString(),
         };
-        const response = await this.futuresPrivatePostChangeCrossUserLeverage(this.extend(request, params));
-        //
-        //    {
-        //        "code": "200000",
-        //        "data": true
-        //    }
-        //
-        const leverageNum = this.safeInteger(response, 'leverage');
+        let uta = await this.isUTAEnabled();
+        [uta, params] = this.handleOptionAndParams(params, 'setLeverage', 'uta', uta);
+        let response = undefined;
+        if (uta) {
+            request['accountMode'] = 'unified';
+            response = await this.utaPrivatePostAccountModeAccountModifyLeverage(this.extend(request, params));
+        }
+        else {
+            //
+            //    {
+            //        "code": "200000",
+            //        "data": true
+            //    }
+            //
+            response = await this.futuresPrivatePostChangeCrossUserLeverage(this.extend(request, params));
+        }
+        const data = this.safeDict(response, 'data', {});
+        const leverageNum = this.safeNumber(data, 'leverage');
         return {
             'info': response,
             'symbol': market['symbol'],
@@ -8425,7 +9802,7 @@ export default class kucoin extends Exchange {
             'symbol': market['id'],
         };
         const until = this.safeInteger(params, 'until');
-        let uta = true; // for backward compatibility, dafult endpoint is uta
+        let uta = false;
         [uta, params] = this.handleOptionAndParams(params, 'fetchFundingRateHistory', 'uta', uta);
         params = this.omit(params, 'until');
         let start = since;
@@ -8580,9 +9957,11 @@ export default class kucoin extends Exchange {
      * @method
      * @name kucoin#fetchPosition
      * @see https://www.kucoin.com/docs-new/rest/futures-trading/positions/get-position-details
+     * @see https://www.kucoin.com/docs-new/rest/ua/get-position-list-uta
      * @description fetch data on an open position
      * @param {string} symbol unified market symbol of the market the position is held in
      * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {boolean} [params.uta] set to true for the unified trading account (uta), defaults to false
      * @returns {object} a [position structure]{@link https://docs.ccxt.com/?id=position-structure}
      */
     async fetchPosition(symbol, params = {}) {
@@ -8591,112 +9970,157 @@ export default class kucoin extends Exchange {
         const request = {
             'symbol': market['id'],
         };
-        const response = await this.futuresPrivateGetPosition(this.extend(request, params));
-        //
-        //    {
-        //        "code": "200000",
-        //        "data": {
-        //            "id": "6505ee6eaff4070001f651c4",
-        //            "symbol": "XBTUSDTM",
-        //            "autoDeposit": false,
-        //            "maintMarginReq": 0,
-        //            "riskLimit": 200,
-        //            "realLeverage": 0.0,
-        //            "crossMode": false,
-        //            "delevPercentage": 0.0,
-        //            "currentTimestamp": 1694887534594,
-        //            "currentQty": 0,
-        //            "currentCost": 0.0,
-        //            "currentComm": 0.0,
-        //            "unrealisedCost": 0.0,
-        //            "realisedGrossCost": 0.0,
-        //            "realisedCost": 0.0,
-        //            "isOpen": false,
-        //            "markPrice": 26611.71,
-        //            "markValue": 0.0,
-        //            "posCost": 0.0,
-        //            "posCross": 0,
-        //            "posInit": 0.0,
-        //            "posComm": 0.0,
-        //            "posLoss": 0.0,
-        //            "posMargin": 0.0,
-        //            "posMaint": 0.0,
-        //            "maintMargin": 0.0,
-        //            "realisedGrossPnl": 0.0,
-        //            "realisedPnl": 0.0,
-        //            "unrealisedPnl": 0.0,
-        //            "unrealisedPnlPcnt": 0,
-        //            "unrealisedRoePcnt": 0,
-        //            "avgEntryPrice": 0.0,
-        //            "liquidationPrice": 0.0,
-        //            "bankruptPrice": 0.0,
-        //            "settleCurrency": "USDT",
-        //            "maintainMargin": 0,
-        //            "riskLimitLevel": 1
-        //        }
-        //    }
-        //
-        const data = this.safeDict(response, 'data', {});
-        return this.parsePosition(data, market);
+        let uta = await this.isUTAEnabled();
+        [uta, params] = this.handleOptionAndParams(params, 'fetchPosition', 'uta', uta);
+        let response = undefined;
+        let position = undefined;
+        if (uta) {
+            request['accountMode'] = 'unified';
+            response = await this.utaPrivateGetAccountModePositionOpenList(this.extend(request, params));
+            //
+            //     {
+            //         "code": "200000",
+            //         "data": [
+            //             {
+            //                 "symbol": "DOGEUSDTM",
+            //                 "id": "30000000000084351",
+            //                 "marginMode": "CROSS",
+            //                 "size": "2",
+            //                 "entryPrice": "0.093795",
+            //                 "positionValue": "18.298",
+            //                 "markPrice": "0.09149",
+            //                 "leverage": "3",
+            //                 "unrealizedPnL": "-0.461",
+            //                 "realizedPnL": "-0.01122489",
+            //                 "initialMargin": "6.0993333327234",
+            //                 "mmr": "0.007",
+            //                 "maintenanceMargin": "0.128086",
+            //                 "creationTime": 1774469753178000000
+            //             }
+            //         ]
+            //     }
+            //
+            const data = this.safeList(response, 'data', []);
+            position = this.safeDict(data, 0, {});
+        }
+        else {
+            response = await this.futuresPrivateGetPosition(this.extend(request, params));
+            //
+            //    {
+            //        "code": "200000",
+            //        "data": {
+            //            "id": "6505ee6eaff4070001f651c4",
+            //            "symbol": "XBTUSDTM",
+            //            "autoDeposit": false,
+            //            "maintMarginReq": 0,
+            //            "riskLimit": 200,
+            //            "realLeverage": 0.0,
+            //            "crossMode": false,
+            //            "delevPercentage": 0.0,
+            //            "currentTimestamp": 1694887534594,
+            //            "currentQty": 0,
+            //            "currentCost": 0.0,
+            //            "currentComm": 0.0,
+            //            "unrealisedCost": 0.0,
+            //            "realisedGrossCost": 0.0,
+            //            "realisedCost": 0.0,
+            //            "isOpen": false,
+            //            "markPrice": 26611.71,
+            //            "markValue": 0.0,
+            //            "posCost": 0.0,
+            //            "posCross": 0,
+            //            "posInit": 0.0,
+            //            "posComm": 0.0,
+            //            "posLoss": 0.0,
+            //            "posMargin": 0.0,
+            //            "posMaint": 0.0,
+            //            "maintMargin": 0.0,
+            //            "realisedGrossPnl": 0.0,
+            //            "realisedPnl": 0.0,
+            //            "unrealisedPnl": 0.0,
+            //            "unrealisedPnlPcnt": 0,
+            //            "unrealisedRoePcnt": 0,
+            //            "avgEntryPrice": 0.0,
+            //            "liquidationPrice": 0.0,
+            //            "bankruptPrice": 0.0,
+            //            "settleCurrency": "USDT",
+            //            "maintainMargin": 0,
+            //            "riskLimitLevel": 1
+            //        }
+            //    }
+            //
+            position = this.safeDict(response, 'data', {});
+        }
+        return this.parsePosition(position, market);
     }
     /**
      * @method
      * @name kucoin#fetchPositions
      * @description fetch all open positions
      * @see https://www.kucoin.com/docs-new/rest/futures-trading/positions/get-position-list
+     * @see https://www.kucoin.com/docs-new/rest/ua/get-position-list-uta
      * @param {string[]|undefined} symbols list of unified market symbols
      * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {boolean} [params.uta] set to true for the unified trading account (uta), defaults to false
      * @returns {object[]} a list of [position structure]{@link https://docs.ccxt.com/?id=position-structure}
      */
     async fetchPositions(symbols = undefined, params = {}) {
         await this.loadMarkets();
-        const response = await this.futuresPrivateGetPositions(params);
-        //
-        //    {
-        //        "code": "200000",
-        //        "data": [
-        //            {
-        //                "id": "615ba79f83a3410001cde321",
-        //                "symbol": "ETHUSDTM",
-        //                "autoDeposit": false,
-        //                "maintMarginReq": 0.005,
-        //                "riskLimit": 1000000,
-        //                "realLeverage": 18.61,
-        //                "crossMode": false,
-        //                "delevPercentage": 0.86,
-        //                "openingTimestamp": 1638563515618,
-        //                "currentTimestamp": 1638576872774,
-        //                "currentQty": 2,
-        //                "currentCost": 83.64200000,
-        //                "currentComm": 0.05018520,
-        //                "unrealisedCost": 83.64200000,
-        //                "realisedGrossCost": 0.00000000,
-        //                "realisedCost": 0.05018520,
-        //                "isOpen": true,
-        //                "markPrice": 4225.01,
-        //                "markValue": 84.50020000,
-        //                "posCost": 83.64200000,
-        //                "posCross": 0.0000000000,
-        //                "posInit": 3.63660870,
-        //                "posComm": 0.05236717,
-        //                "posLoss": 0.00000000,
-        //                "posMargin": 3.68897586,
-        //                "posMaint": 0.50637594,
-        //                "maintMargin": 4.54717586,
-        //                "realisedGrossPnl": 0.00000000,
-        //                "realisedPnl": -0.05018520,
-        //                "unrealisedPnl": 0.85820000,
-        //                "unrealisedPnlPcnt": 0.0103,
-        //                "unrealisedRoePcnt": 0.2360,
-        //                "avgEntryPrice": 4182.10,
-        //                "liquidationPrice": 4023.00,
-        //                "bankruptPrice": 4000.25,
-        //                "settleCurrency": "USDT",
-        //                "isInverse": false
-        //            }
-        //        ]
-        //    }
-        //
+        let uta = await this.isUTAEnabled();
+        [uta, params] = this.handleOptionAndParams(params, 'fetchPositions', 'uta', uta);
+        let response = undefined;
+        if (uta) {
+            response = await this.utaPrivateGetAccountModePositionOpenList(this.extend(params, { 'accountMode': 'unified' }));
+        }
+        else {
+            response = await this.futuresPrivateGetPositions(params);
+            //
+            //    {
+            //        "code": "200000",
+            //        "data": [
+            //            {
+            //                "id": "615ba79f83a3410001cde321",
+            //                "symbol": "ETHUSDTM",
+            //                "autoDeposit": false,
+            //                "maintMarginReq": 0.005,
+            //                "riskLimit": 1000000,
+            //                "realLeverage": 18.61,
+            //                "crossMode": false,
+            //                "delevPercentage": 0.86,
+            //                "openingTimestamp": 1638563515618,
+            //                "currentTimestamp": 1638576872774,
+            //                "currentQty": 2,
+            //                "currentCost": 83.64200000,
+            //                "currentComm": 0.05018520,
+            //                "unrealisedCost": 83.64200000,
+            //                "realisedGrossCost": 0.00000000,
+            //                "realisedCost": 0.05018520,
+            //                "isOpen": true,
+            //                "markPrice": 4225.01,
+            //                "markValue": 84.50020000,
+            //                "posCost": 83.64200000,
+            //                "posCross": 0.0000000000,
+            //                "posInit": 3.63660870,
+            //                "posComm": 0.05236717,
+            //                "posLoss": 0.00000000,
+            //                "posMargin": 3.68897586,
+            //                "posMaint": 0.50637594,
+            //                "maintMargin": 4.54717586,
+            //                "realisedGrossPnl": 0.00000000,
+            //                "realisedPnl": -0.05018520,
+            //                "unrealisedPnl": 0.85820000,
+            //                "unrealisedPnlPcnt": 0.0103,
+            //                "unrealisedRoePcnt": 0.2360,
+            //                "avgEntryPrice": 4182.10,
+            //                "liquidationPrice": 4023.00,
+            //                "bankruptPrice": 4000.25,
+            //                "settleCurrency": "USDT",
+            //                "isInverse": false
+            //            }
+            //        ]
+            //    }
+            //
+        }
         const data = this.safeList(response, 'data');
         return this.parsePositions(data, symbols);
     }
@@ -8705,69 +10129,120 @@ export default class kucoin extends Exchange {
      * @name kucoin#fetchPositionsHistory
      * @description fetches historical positions
      * @see https://www.kucoin.com/docs-new/rest/futures-trading/positions/get-positions-history
+     * @see https://www.kucoin.com/docs-new/rest/ua/get-position-history-uta
      * @param {string[]} [symbols] list of unified market symbols
      * @param {int} [since] the earliest time in ms to fetch position history for
      * @param {int} [limit] the maximum number of entries to retrieve
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @param {int} [params.until] closing end time
      * @param {int} [params.pageId] page id
+     * @param {boolean} [params.uta] set to true for the unified trading account (uta), defaults to false
      * @returns {object[]} a list of [position structure]{@link https://docs.ccxt.com/?id=position-structure}
      */
     async fetchPositionsHistory(symbols = undefined, since = undefined, limit = undefined, params = {}) {
         await this.loadMarkets();
-        if (limit === undefined) {
-            limit = 200;
+        let uta = await this.isUTAEnabled();
+        [uta, params] = this.handleOptionAndParams(params, 'fetchPositionsHistory', 'uta', uta);
+        let response = undefined;
+        let request = {};
+        symbols = this.marketSymbols(symbols);
+        if (symbols !== undefined) {
+            const length = symbols.length;
+            if (length === 1) {
+                const market = this.market(symbols[0]);
+                request['symbol'] = market['id'];
+            }
         }
-        const request = {
-            'limit': limit,
-        };
-        if (since !== undefined) {
-            request['from'] = since;
+        if (uta) {
+            if (since !== undefined) {
+                request['startAt'] = since;
+            }
+            if (limit !== undefined) {
+                request['pageSize'] = limit;
+            }
+            [request, params] = this.handleUntilOption('endAt', request, params);
+            //
+            //     {
+            //         "code": "200000",
+            //         "data": {
+            //             "items": [
+            //                 {
+            //                     "symbol": "DOGEUSDTM",
+            //                     "closeId": "30000000000162175",
+            //                     "marginMode": "CROSS",
+            //                     "side": "LONG",
+            //                     "entryPrice": "0.09641",
+            //                     "closePrice": "0.09613",
+            //                     "maxSize": "1",
+            //                     "avgClosePrice": "0.09613",
+            //                     "leverage": "3",
+            //                     "realizedPnL": "-0.0395524",
+            //                     "fee": "0.0115524",
+            //                     "tax": "0",
+            //                     "fundingFee": "0",
+            //                     "closingTime": 1774469647311000000,
+            //                     "creationTime": 1774468501294000000
+            //                 }
+            //             ],
+            //             "lastId": 30000000000162175
+            //         }
+            //     }
+            //
+            response = await this.utaPrivateGetPositionHistory(this.extend(request, params));
         }
-        const until = this.safeInteger(params, 'until');
-        if (until !== undefined) {
-            params = this.omit(params, 'until');
-            request['to'] = until;
+        else {
+            if (limit === undefined) {
+                limit = 200;
+            }
+            request['limit'] = limit;
+            if (since !== undefined) {
+                request['from'] = since;
+            }
+            const until = this.safeInteger(params, 'until');
+            if (until !== undefined) {
+                params = this.omit(params, 'until');
+                request['to'] = until;
+            }
+            //
+            // {
+            //     "success": true,
+            //     "code": "200",
+            //     "msg": "success",
+            //     "retry": false,
+            //     "data": {
+            //         "currentPage": 1,
+            //         "pageSize": 10,
+            //         "totalNum": 25,
+            //         "totalPage": 3,
+            //         "items": [
+            //             {
+            //                 "closeId": "300000000000000030",
+            //                 "positionId": "300000000000000009",
+            //                 "uid": 99996908309485,
+            //                 "userId": "6527d4fc8c7f3d0001f40f5f",
+            //                 "symbol": "XBTUSDM",
+            //                 "settleCurrency": "XBT",
+            //                 "leverage": "0.0",
+            //                 "type": "LIQUID_LONG",
+            //                 "side": null,
+            //                 "closeSize": null,
+            //                 "pnl": "-1.0000003793999999",
+            //                 "realisedGrossCost": "0.9993849748999999",
+            //                 "withdrawPnl": "0.0",
+            //                 "roe": null,
+            //                 "tradeFee": "0.0006154045",
+            //                 "fundingFee": "0.0",
+            //                 "openTime": 1713785751181,
+            //                 "closeTime": 1713785752784,
+            //                 "openPrice": null,
+            //                 "closePrice": null
+            //             }
+            //         ]
+            //     }
+            // }
+            //
+            response = await this.futuresPrivateGetHistoryPositions(this.extend(request, params));
         }
-        const response = await this.futuresPrivateGetHistoryPositions(this.extend(request, params));
-        //
-        // {
-        //     "success": true,
-        //     "code": "200",
-        //     "msg": "success",
-        //     "retry": false,
-        //     "data": {
-        //         "currentPage": 1,
-        //         "pageSize": 10,
-        //         "totalNum": 25,
-        //         "totalPage": 3,
-        //         "items": [
-        //             {
-        //                 "closeId": "300000000000000030",
-        //                 "positionId": "300000000000000009",
-        //                 "uid": 99996908309485,
-        //                 "userId": "6527d4fc8c7f3d0001f40f5f",
-        //                 "symbol": "XBTUSDM",
-        //                 "settleCurrency": "XBT",
-        //                 "leverage": "0.0",
-        //                 "type": "LIQUID_LONG",
-        //                 "side": null,
-        //                 "closeSize": null,
-        //                 "pnl": "-1.0000003793999999",
-        //                 "realisedGrossCost": "0.9993849748999999",
-        //                 "withdrawPnl": "0.0",
-        //                 "roe": null,
-        //                 "tradeFee": "0.0006154045",
-        //                 "fundingFee": "0.0",
-        //                 "openTime": 1713785751181,
-        //                 "closeTime": 1713785752784,
-        //                 "openPrice": null,
-        //                 "closePrice": null
-        //             }
-        //         ]
-        //     }
-        // }
-        //
         const data = this.safeDict(response, 'data');
         const items = this.safeList(data, 'items', []);
         return this.parsePositions(items, symbols);
@@ -8842,61 +10317,107 @@ export default class kucoin extends Exchange {
         //                 "closePrice": null
         //             }
         //
+        // uta fetchPositions
+        //     {
+        //         "symbol": "DOGEUSDTM",
+        //         "id": "30000000000084351",
+        //         "marginMode": "CROSS",
+        //         "size": "2",
+        //         "entryPrice": "0.093795",
+        //         "positionValue": "18.298",
+        //         "markPrice": "0.09149",
+        //         "leverage": "3",
+        //         "unrealizedPnL": "-0.461",
+        //         "realizedPnL": "-0.01122489",
+        //         "initialMargin": "6.0993333327234",
+        //         "mmr": "0.007",
+        //         "maintenanceMargin": "0.128086",
+        //         "creationTime": 1774469753178000000
+        //     }
+        //
+        // uta fetchPositionsHistory
+        //     {
+        //         "symbol": "DOGEUSDTM",
+        //         "closeId": "30000000000162175",
+        //         "marginMode": "CROSS",
+        //         "side": "LONG",
+        //         "entryPrice": "0.09641",
+        //         "closePrice": "0.09613",
+        //         "maxSize": "1",
+        //         "avgClosePrice": "0.09613",
+        //         "leverage": "3",
+        //         "realizedPnL": "-0.0395524",
+        //         "fee": "0.0115524",
+        //         "tax": "0",
+        //         "fundingFee": "0",
+        //         "closingTime": 1774469647311000000,
+        //         "creationTime": 1774468501294000000
+        //     }
+        //
         const symbol = this.safeString(position, 'symbol');
         market = this.safeMarket(symbol, market);
-        const timestamp = this.safeInteger(position, 'currentTimestamp');
-        const size = this.safeString(position, 'currentQty');
-        let side = undefined;
-        const type = this.safeStringLower(position, 'type');
-        if (size !== undefined) {
-            if (Precise.stringGt(size, '0')) {
-                side = 'long';
-            }
-            else if (Precise.stringLt(size, '0')) {
-                side = 'short';
-            }
+        let timestamp = this.safeInteger(position, 'currentTimestamp');
+        if (timestamp === undefined) {
+            timestamp = this.safeIntegerProduct(position, 'creationTime', 0.000001);
         }
-        else if (type !== undefined) {
-            if (type.indexOf('long') > -1) {
-                side = 'long';
+        const size = this.safeStringN(position, ['currentQty', 'size', 'maxSize', 'closeSize']);
+        let side = this.safeStringLower(position, 'side');
+        const type = this.safeStringLower(position, 'type');
+        if (side === undefined) {
+            if (size !== undefined) {
+                if (Precise.stringGt(size, '0')) {
+                    side = 'long';
+                }
+                else if (Precise.stringLt(size, '0')) {
+                    side = 'short';
+                }
             }
-            else {
-                side = 'short';
+            else if (type !== undefined) {
+                if (type.indexOf('long') > -1) {
+                    side = 'long';
+                }
+                else {
+                    side = 'short';
+                }
             }
         }
-        const notional = Precise.stringAbs(this.safeString(position, 'posCost'));
-        const initialMargin = this.safeString(position, 'posInit');
+        const notional = Precise.stringAbs(this.safeString2(position, 'posCost', 'positionValue'));
+        const initialMargin = this.safeString2(position, 'posInit', 'initialMargin');
         const initialMarginPercentage = Precise.stringDiv(initialMargin, notional);
         // const marginRatio = Precise.stringDiv (maintenanceRate, collateral);
-        const unrealisedPnl = this.safeString(position, 'unrealisedPnl');
+        const unrealisedPnl = this.safeString2(position, 'unrealisedPnl', 'unrealizedPnL');
         const crossMode = this.safeValue(position, 'crossMode');
         // currently crossMode is always set to false and only isolated positions are supported
-        let marginMode = undefined;
+        let marginMode = this.safeStringLower(position, 'marginMode');
         if (crossMode !== undefined) {
             marginMode = crossMode ? 'cross' : 'isolated';
         }
+        let lastUpdateTimestamp = this.safeInteger(position, 'closeTime');
+        if (lastUpdateTimestamp === undefined) {
+            lastUpdateTimestamp = this.safeIntegerProduct(position, 'closingTime', 0.000001);
+        }
         return this.safePosition({
             'info': position,
-            'id': this.safeString2(position, 'id', 'positionId'),
+            'id': this.safeStringN(position, ['id', 'positionId', 'closeId']),
             'symbol': this.safeString(market, 'symbol'),
             'timestamp': timestamp,
             'datetime': this.iso8601(timestamp),
-            'lastUpdateTimestamp': this.safeInteger(position, 'closeTime'),
+            'lastUpdateTimestamp': lastUpdateTimestamp,
             'initialMargin': this.parseNumber(initialMargin),
             'initialMarginPercentage': this.parseNumber(initialMarginPercentage),
-            'maintenanceMargin': this.safeNumber(position, 'posMaint'),
-            'maintenanceMarginPercentage': this.safeNumber(position, 'maintMarginReq'),
-            'entryPrice': this.safeNumber2(position, 'avgEntryPrice', 'openPrice'),
+            'maintenanceMargin': this.safeNumber2(position, 'posMaint', 'maintenanceMargin'),
+            'maintenanceMarginPercentage': this.safeNumber2(position, 'maintMarginReq', 'mmr'),
+            'entryPrice': this.safeNumberN(position, ['avgEntryPrice', 'openPrice', 'entryPrice']),
             'notional': this.parseNumber(notional),
             'leverage': this.safeNumber2(position, 'realLeverage', 'leverage'),
             'unrealizedPnl': this.parseNumber(unrealisedPnl),
             'contracts': this.parseNumber(Precise.stringAbs(size)),
             'contractSize': this.safeValue(market, 'contractSize'),
-            'realizedPnl': this.safeNumber2(position, 'realisedPnl', 'pnl'),
+            'realizedPnl': this.safeNumberN(position, ['realisedPnl', 'pnl', 'realizedPnL']),
             'marginRatio': undefined,
             'liquidationPrice': this.safeNumber(position, 'liquidationPrice'),
             'markPrice': this.safeNumber(position, 'markPrice'),
-            'lastPrice': undefined,
+            'lastPrice': this.safeNumber(position, 'closePrice'),
             'collateral': this.safeNumber(position, 'maintMargin'),
             'marginMode': marginMode,
             'side': side,
@@ -8910,18 +10431,31 @@ export default class kucoin extends Exchange {
      * @name kucoin#cancelOrders
      * @description cancel multiple orders for contract markets
      * @see https://www.kucoin.com/docs-new/3470241e0
+     * @see https://www.kucoin.com/docs-new/rest/ua/batch-cancel-order-by-id
      * @param {string[]} ids order ids
      * @param {string} symbol unified symbol of the market the order was made in
      * @param {object} [params] extra parameters specific to the exchange API endpoint
      * @param {string[]} [params.clientOrderIds] client order ids
+     * @param {boolean} [params.uta] set to true to use the unified trading account (uta) endpoint, defaults to false for the contract orders
+     * @param {string} [params.accountMode] *for uta endpoint only* 'unified' or 'classic' (default is 'unified')
+     * @param {string} [params.marginMode] *for margin orders only* 'cross' or 'isolated'
      * @returns {object} an list of [order structures]{@link https://docs.ccxt.com/?id=order-structure}
      */
     async cancelOrders(ids, symbol = undefined, params = {}) {
-        // contract markets only
         await this.loadMarkets();
+        let uta = await this.isUTAEnabled();
+        [uta, params] = this.handleOptionAndParams(params, 'cancelOrders', 'uta', uta);
         let market = undefined;
+        let isContractMarket = true; // default to contract market orders if symbol is not provided, uta endpoint requires a symbol to be provided
         if (symbol !== undefined) {
             market = this.market(symbol);
+            isContractMarket = market['contract'];
+            if (!isContractMarket) {
+                uta = true; // spot market orders can only be cancelled via the uta endpoint
+            }
+        }
+        else if (uta) {
+            throw new ArgumentsRequired(this.id + ' cancelOrders() requires a symbol argument for uta endpoint');
         }
         const ordersRequests = [];
         const clientOrderIds = this.safeList2(params, 'clientOrderIds', 'clientOids', []);
@@ -8938,33 +10472,59 @@ export default class kucoin extends Exchange {
             });
         }
         for (let i = 0; i < ids.length; i++) {
-            ordersRequests.push(ids[i]);
+            const orderId = ids[i];
+            if (uta) {
+                ordersRequests.push({
+                    'orderId': orderId,
+                    'symbol': market['id'],
+                });
+            }
+            else {
+                ordersRequests.push(ids[i]);
+            }
         }
-        const requestKey = useClientorderId ? 'clientOidsList' : 'orderIdsList';
         const request = {};
-        request[requestKey] = ordersRequests;
-        const response = await this.futuresPrivateDeleteOrdersMultiCancel(this.extend(request, params));
-        //
-        //   {
-        //       "code": "200000",
-        //       "data":
-        //       [
-        //           {
-        //               "orderId": "80465574458560512",
-        //               "clientOid": null,
-        //               "code": "200",
-        //               "msg": "success"
-        //           },
-        //           {
-        //               "orderId": "80465575289094144",
-        //               "clientOid": null,
-        //               "code": "200",
-        //               "msg": "success"
-        //           }
-        //       ]
-        //   }
-        //
-        const orders = this.safeList(response, 'data', []);
+        let response = undefined;
+        let orders = [];
+        if (uta) {
+            let accountMode = 'unified';
+            [accountMode, params] = this.handleOptionAndParams(params, 'cancelOrders', 'accountMode', accountMode);
+            request['accountMode'] = accountMode;
+            let marginMode = undefined;
+            [marginMode, params] = this.handleMarginModeAndParams('fetchOrder', params);
+            const tradeType = this.handleTradeType(isContractMarket, marginMode, params);
+            request['tradeType'] = tradeType;
+            request['cancelOrderList'] = ordersRequests;
+            response = await this.utaPrivatePostAccountModeOrderCancelBatch(this.extend(request, params));
+            const data = this.safeDict(response, 'data', {});
+            orders = this.safeList(data, 'items', []);
+        }
+        else {
+            const requestKey = useClientorderId ? 'clientOidsList' : 'orderIdsList';
+            request[requestKey] = ordersRequests;
+            response = await this.futuresPrivateDeleteOrdersMultiCancel(this.extend(request, params));
+            //
+            //   {
+            //       "code": "200000",
+            //       "data":
+            //       [
+            //           {
+            //               "orderId": "80465574458560512",
+            //               "clientOid": null,
+            //               "code": "200",
+            //               "msg": "success"
+            //           },
+            //           {
+            //               "orderId": "80465575289094144",
+            //               "clientOid": null,
+            //               "code": "200",
+            //               "msg": "success"
+            //           }
+            //       ]
+            //   }
+            //
+            orders = this.safeList(response, 'data', []);
+        }
         return this.parseOrders(orders, market);
     }
     /**
@@ -9429,6 +10989,139 @@ export default class kucoin extends Exchange {
         }
         return result;
     }
+    /**
+     * @method
+     * @name kucoin#fetchOpenInterests
+     * @description Retrieves the open interest for a list of symbols
+     * @see https://www.kucoin.com/docs-new/rest/ua/get-futures-open-interset
+     * @param {string[]} [symbols] Unified CCXT market symbol
+     * @param {object} [params] exchange specific parameters
+     * @returns {object} an open interest structure{@link https://docs.ccxt.com/?id=open-interest-structure}
+     */
+    async fetchOpenInterests(symbols = undefined, params = {}) {
+        await this.loadMarkets();
+        symbols = this.marketSymbols(symbols);
+        const request = {};
+        if (symbols !== undefined) {
+            const length = symbols.length;
+            if (length < 11) {
+                // the endpoint does not accept more than 10 symbols at a time
+                // if user provided more than 10 symbols, we will fetch all symbols
+                const marketIds = this.marketIds(symbols);
+                request['symbol'] = marketIds.join(',');
+            }
+        }
+        const response = await this.utaGetMarketOpenInterest(this.extend(request, params));
+        //
+        //     {
+        //         "code": "200000",
+        //         "data": [
+        //             {
+        //                 "symbol": "ETHUSDTM",
+        //                 "openInterest": "8053960",
+        //                 "ts": 1774007467050
+        //             }
+        //         ]
+        //     }
+        //
+        const data = this.safeList(response, 'data', []);
+        return this.parseOpenInterests(data, symbols);
+    }
+    parseOpenInterest(interest, market = undefined) {
+        //
+        //     {
+        //         "symbol": "ETHUSDTM",
+        //         "openInterest": "8053960",
+        //         "ts": 1774007467050
+        //     }
+        //
+        const marketId = this.safeString(interest, 'symbol');
+        market = this.safeMarket(marketId, market);
+        const timestamp = this.safeInteger(interest, 'ts');
+        return this.safeOpenInterest({
+            'symbol': this.safeSymbol(marketId),
+            'openInterestAmount': this.safeNumber(interest, 'openInterest'),
+            'openInterestValue': undefined,
+            'timestamp': timestamp,
+            'datetime': this.iso8601(timestamp),
+            'info': interest,
+        }, market);
+    }
+    /**
+     * @method
+     * @name kucoin#fetchOpenInterestHistory
+     * @description Retrieves the open interest history of a currency
+     * @see https://www.kucoin.com/docs-new/rest/ua/get-futures-open-interset
+     * @param {string} symbol Unified CCXT market symbol
+     * @param {string} timeframe '5m', '15m', '30m', '1h', '4h' or '1d'
+     * @param {int} [since] the time(ms) of the earliest record to retrieve as a unix timestamp
+     * @param {int} [limit] default 30，max 200
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @param {int} [params.until] the latest time in ms to fetch entries for
+     * @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)
+     * @returns {object} an array of [open interest structures]{@link https://docs.ccxt.com/?id=open-interest-structure}
+     */
+    async fetchOpenInterestHistory(symbol, timeframe = '5m', since = undefined, limit = undefined, params = {}) {
+        const timeframes = {
+            '5m': '5min',
+            '15m': '15min',
+            '30m': '30min',
+            '1h': '1hour',
+            '4h': '4hour',
+            '1d': '1day',
+            '5min': '5min',
+            '15min': '15min',
+            '30min': '30min',
+            '1hour': '1hour',
+            '4hour': '4hour',
+            '1day': '1day',
+        };
+        const interval = this.safeString(timeframes, timeframe);
+        if (interval === undefined) {
+            throw new BadRequest(this.id + ' fetchOpenInterestHistory() invalid timeframe, supported are 5m, 15m, 30m, 1h, 4h, 1d');
+        }
+        await this.loadMarkets();
+        const market = this.market(symbol);
+        const maxLimit = 200;
+        let paginate = false;
+        [paginate, params] = this.handleOptionAndParams(params, 'fetchOpenInterestHistory', 'paginate', paginate);
+        if (paginate) {
+            return await this.fetchPaginatedCallDeterministic('fetchOpenInterestHistory', symbol, since, limit, timeframe, params, maxLimit);
+        }
+        let request = {
+            'symbol': market['id'],
+            'interval': interval,
+        };
+        if (since !== undefined) {
+            request['startAt'] = since;
+        }
+        if (limit !== undefined) {
+            request['pageSize'] = limit;
+        }
+        [request, params] = this.handleUntilOption('endAt', request, params);
+        const response = await this.utaGetMarketOpenInterest(this.extend(request, params));
+        const data = this.safeList(response, 'data');
+        return this.parseOpenInterestsHistory(data, market, since, limit);
+    }
+    /**
+     * @method
+     * @name kucoin#isUTAEnabled
+     * @see https://www.kucoin.com/docs-new/rest/ua/get-account-mode
+     * @description returns true or false so the user can check if unified account is enabled
+     * @param {object} [params] extra parameters specific to the exchange API endpoint
+     * @returns {boolean} true if unified account is enabled, false otherwise
+     */
+    async isUTAEnabled(params = {}) {
+        let uta = this.safeBool(this.options, 'uta');
+        if (uta === undefined) {
+            const response = await this.utaPrivateGetAccountMode(params);
+            const data = this.safeDict(response, 'data', {});
+            const accountMode = this.safeString(data, 'selfAccountMode');
+            uta = (accountMode === 'UNIFIED');
+            this.options['uta'] = uta;
+        }
+        return this.safeBool(this.options, 'uta', false);
+    }
     sign(path, api = 'public', method = 'GET', params = {}, headers = undefined, body = undefined) {
         //
         // the v2 URL is https://openapi-v2.kucoin.com/api/v1/endpoint
@@ -9459,11 +11152,15 @@ export default class kucoin extends Exchange {
         let endpart = '';
         headers = (headers !== undefined) ? headers : {};
         let url = this.urls['api'][api];
+        const tradeType = this.safeString(query, 'tradeType');
         if (!this.isEmpty(query)) {
             if (((method === 'GET') || (method === 'DELETE')) && (path !== 'orders/multi-cancel')) {
                 endpoint += '?' + this.rawencode(query);
             }
             else {
+                if (endpoint === '/api/ua/v1/classic/order/place') {
+                    endpoint += '?tradeType=' + tradeType;
+                }
                 body = this.json(query);
                 endpart = body;
                 headers['Content-Type'] = 'application/json';
@@ -9494,7 +11191,9 @@ export default class kucoin extends Exchange {
             const signature = this.hmac(this.encode(payload), this.encode(this.secret), sha256, 'base64');
             headers['KC-API-SIGN'] = signature;
             let partner = this.safeDict(this.options, 'partner', {});
-            partner = isFuturePrivate ? this.safeValue(partner, 'future', partner) : this.safeValue(partner, 'spot', partner);
+            const isUtaFuturePrivate = isUtaPrivate && (tradeType === 'FUTURES');
+            const isFuturePartner = isFuturePrivate || isUtaFuturePrivate;
+            partner = isFuturePartner ? this.safeValue(partner, 'future', partner) : this.safeValue(partner, 'spot', partner);
             const partnerId = this.safeString(partner, 'id');
             const partnerSecret = this.safeString2(partner, 'secret', 'key');
             if ((partnerId !== undefined) && (partnerSecret !== undefined)) {