From b9b64a493bdac193285a6c027f375862550c6a69 Mon Sep 17 00:00:00 2001
From: siandreev <andreev.sergey.i@yandex.ru>
Date: Fri, 7 Feb 2025 21:35:29 +0700
Subject: [PATCH] feat: import wallet by sk

---
 packages/core/src/entries/account.ts          |  50 ++++-
 packages/core/src/entries/dashboard.ts        |   1 +
 packages/core/src/entries/password.ts         |   2 +-
 packages/core/src/service/accountsStorage.ts  |  26 ++-
 packages/core/src/service/mnemonicService.ts  |  61 +++++-
 packages/core/src/service/passwordService.ts  |  17 +-
 packages/core/src/service/walletService.ts    |  70 ++++++-
 packages/locales/src/tonkeeper-web/en.json    |   4 +
 packages/locales/src/tonkeeper-web/ru-RU.json |   4 +
 .../src/components/account/AccountBadge.tsx   |   2 +-
 .../components/create/ChoseWalletVersions.tsx |  33 +++-
 .../uikit/src/components/create/SKInput.tsx   |  83 ++++++++
 .../desktop/aside/AsideMenuAccount.tsx        |   7 +-
 .../settings/DesktopManageWalletsSettings.tsx |   4 +-
 .../src/pages/import/ImportBySKWallet.tsx     | 182 ++++++++++++++++++
 .../src/pages/import/ImportExistingWallet.tsx |   4 +-
 .../src/pages/import/ImportTestnetWallet.tsx  |   6 +-
 packages/uikit/src/pages/settings/Dev.tsx     |  20 ++
 .../uikit/src/pages/settings/Recovery.tsx     |  60 ++++--
 packages/uikit/src/state/mnemonic.ts          |  86 ++++++---
 packages/uikit/src/state/wallet.ts            | 123 ++++++++++--
 21 files changed, 741 insertions(+), 104 deletions(-)
 create mode 100644 packages/uikit/src/components/create/SKInput.tsx
 create mode 100644 packages/uikit/src/pages/import/ImportBySKWallet.tsx

diff --git a/packages/core/src/entries/account.ts b/packages/core/src/entries/account.ts
index 7878e47f5..cb241d19f 100644
--- a/packages/core/src/entries/account.ts
+++ b/packages/core/src/entries/account.ts
@@ -189,6 +189,28 @@ export class AccountTonTestnet extends TonMnemonic {
     }
 }
 
+export class AccountTonSK extends TonMnemonic {
+    public readonly type = 'sk';
+
+    static create(params: {
+        id: AccountId;
+        name: string;
+        emoji: string;
+        auth: AuthPassword | AuthKeychain;
+        activeTonWalletId: WalletId;
+        tonWallets: TonWalletStandard[];
+    }) {
+        return new AccountTonSK(
+            params.id,
+            params.name,
+            params.emoji,
+            params.auth,
+            params.activeTonWalletId,
+            params.tonWallets
+        );
+    }
+}
+
 export class AccountTonWatchOnly extends Clonable implements IAccount {
     public readonly type = 'watch-only';
 
@@ -655,7 +677,11 @@ export class AccountTonMultisig extends Clonable implements IAccount {
     }
 }
 
-export type AccountVersionEditable = AccountTonMnemonic | AccountTonOnly | AccountTonTestnet;
+export type AccountVersionEditable =
+    | AccountTonMnemonic
+    | AccountTonOnly
+    | AccountTonTestnet
+    | AccountTonSK;
 
 export type AccountTonWalletStandard =
     | AccountVersionEditable
@@ -670,6 +696,7 @@ export function isAccountVersionEditable(account: Account): account is AccountVe
         case 'mnemonic':
         case 'ton-only':
         case 'testnet':
+        case 'sk':
             return true;
         case 'ledger':
         case 'keystone':
@@ -690,6 +717,7 @@ export function isAccountTonWalletStandard(account: Account): account is Account
         case 'ton-only':
         case 'mam':
         case 'testnet':
+        case 'sk':
             return true;
         case 'watch-only':
         case 'ton-multisig':
@@ -705,6 +733,7 @@ export function isAccountCanManageMultisigs(account: Account): boolean {
         case 'ton-only':
         case 'mam':
         case 'ledger':
+        case 'sk':
             return true;
         case 'watch-only':
         case 'ton-multisig':
@@ -723,6 +752,7 @@ export function isMnemonicAndPassword(
         case 'mam':
         case 'mnemonic':
         case 'testnet':
+        case 'sk':
             return true;
         case 'ton-only':
         case 'ledger':
@@ -746,6 +776,7 @@ export function getNetworkByAccount(account: Account): Network {
         case 'watch-only':
         case 'ton-multisig':
         case 'keystone':
+        case 'sk':
             return Network.MAINNET;
         default:
             assertUnreachable(account);
@@ -770,6 +801,7 @@ export function isAccountTronCompatible(
         case 'watch-only':
         case 'ton-multisig':
         case 'keystone':
+        case 'sk':
             return false;
         default:
             return assertUnreachable(account);
@@ -787,6 +819,7 @@ export function isAccountBip39(account: Account) {
         case 'watch-only':
         case 'ton-multisig':
         case 'keystone':
+        case 'sk':
             return false;
         default:
             return assertUnreachable(account);
@@ -809,7 +842,8 @@ const prototypes = {
     'ton-only': AccountTonOnly.prototype,
     'watch-only': AccountTonWatchOnly.prototype,
     mam: AccountMAM.prototype,
-    'ton-multisig': AccountTonMultisig.prototype
+    'ton-multisig': AccountTonMultisig.prototype,
+    sk: AccountTonSK.prototype
 } as const;
 
 export function bindAccountToClass(accountStruct: Account): void {
@@ -844,3 +878,15 @@ export type AccountsFolderStored = {
     name: string;
     lastIsOpened: boolean;
 };
+
+export type AccountSecretMnemonic = {
+    type: 'mnemonic';
+    mnemonic: string[];
+};
+
+export type AccountSecretSK = {
+    type: 'sk';
+    sk: string;
+};
+
+export type AccountSecret = AccountSecretMnemonic | AccountSecretSK;
diff --git a/packages/core/src/entries/dashboard.ts b/packages/core/src/entries/dashboard.ts
index f69ee10b0..80cc79849 100644
--- a/packages/core/src/entries/dashboard.ts
+++ b/packages/core/src/entries/dashboard.ts
@@ -141,6 +141,7 @@ function accountAndWalletToString(account: Account, walletId: WalletId): string
         case 'ton-only':
         case 'mnemonic':
         case 'testnet':
+        case 'sk':
             if (account.allTonWallets.length === 1) {
                 return baseInfo;
             }
diff --git a/packages/core/src/entries/password.ts b/packages/core/src/entries/password.ts
index bd5c9da78..6e6d8922e 100644
--- a/packages/core/src/entries/password.ts
+++ b/packages/core/src/entries/password.ts
@@ -12,7 +12,7 @@ export type MnemonicType = 'ton' | 'bip39';
 
 export interface AuthPassword {
     kind: 'password';
-    encryptedMnemonic: string;
+    encryptedSecret: string;
 }
 
 export interface AuthKeychain {
diff --git a/packages/core/src/service/accountsStorage.ts b/packages/core/src/service/accountsStorage.ts
index 4a09a0055..c6ba1707b 100644
--- a/packages/core/src/service/accountsStorage.ts
+++ b/packages/core/src/service/accountsStorage.ts
@@ -37,6 +37,8 @@ export class AccountsStorage {
         } else {
             state.forEach(bindAccountToClass);
         }
+
+        await this.migrateAccountSecret(state);
         return state ?? defaultAccountState;
     };
 
@@ -190,6 +192,28 @@ export class AccountsStorage {
             )?.id || null
         );
     };
+
+    private migrateAccountSecret = async (accounts: Account[] | null) => {
+        if (!accounts) {
+            return;
+        }
+        let needUpdate = false;
+
+        accounts.forEach(account => {
+            if ('auth' in account && account.auth.kind === 'password') {
+                if ((account.auth as unknown as { encryptedMnemonic: string }).encryptedMnemonic) {
+                    account.auth.encryptedSecret = (
+                        account.auth as unknown as { encryptedMnemonic: string }
+                    ).encryptedMnemonic;
+                    needUpdate = true;
+                }
+            }
+        });
+
+        if (needUpdate) {
+            await this.setAccounts(accounts);
+        }
+    };
 }
 
 export const accountsStorage = (storage: IStorage): AccountsStorage => new AccountsStorage(storage);
@@ -237,7 +261,7 @@ async function migrateToAccountsState(storage: IStorage): Promise<AccountsState
 
                 auth = {
                     kind: walletAuth.kind,
-                    encryptedMnemonic
+                    encryptedSecret: encryptedMnemonic
                 };
             } else if (walletAuth.kind === 'keychain') {
                 auth = {
diff --git a/packages/core/src/service/mnemonicService.ts b/packages/core/src/service/mnemonicService.ts
index 6fcdecd69..d9e3f2a2d 100644
--- a/packages/core/src/service/mnemonicService.ts
+++ b/packages/core/src/service/mnemonicService.ts
@@ -4,19 +4,64 @@ import {
     mnemonicToPrivateKey,
     mnemonicValidate as validateStandardTonMnemonic
 } from '@ton/crypto';
-import { AuthPassword, MnemonicType } from '../entries/password';
-import { decrypt } from './cryptoService';
+import { MnemonicType } from '../entries/password';
+import { decrypt, encrypt } from './cryptoService';
 import { mnemonicToSeed, validateMnemonic as validBip39Mnemonic } from 'bip39';
 import { deriveED25519Path } from './ed25519';
 import { assertUnreachable } from '../utils/types';
+import { AccountSecret } from '../entries/account';
 
-export const decryptWalletMnemonic = async (state: { auth: AuthPassword }, password: string) => {
-    const mnemonic = (await decrypt(state.auth.encryptedMnemonic, password)).split(' ');
-    const isValid = await seeIfMnemonicValid(mnemonic);
-    if (!isValid) {
-        throw new Error('Wallet mnemonic not valid');
+export const decryptWalletSecret = async (
+    encryptedSecret: string,
+    password: string
+): Promise<AccountSecret> => {
+    const secret = await decrypt(encryptedSecret, password);
+    return walletSecretFromString(secret);
+
+    throw new Error('Wallet secret not valid');
+};
+
+export const walletSecretFromString = async (secret: string): Promise<AccountSecret> => {
+    const isValidMnemonic = await seeIfMnemonicValid(secret.split(' '));
+    if (isValidMnemonic) {
+        return {
+            type: 'mnemonic',
+            mnemonic: secret.split(' ')
+        };
     }
-    return mnemonic;
+
+    if (isValidSK(secret)) {
+        return {
+            type: 'sk',
+            sk: secret
+        };
+    }
+
+    throw new Error('Wallet secret not valid');
+};
+
+export const walletSecretToString = (secret: AccountSecret): string => {
+    if (secret.type === 'mnemonic') {
+        return secret.mnemonic.join(' ');
+    }
+
+    if (secret.type === 'sk') {
+        return secret.sk;
+    }
+
+    assertUnreachable(secret);
+};
+
+export const encryptWalletSecret = async (
+    secret: AccountSecret,
+    password: string
+): Promise<string> => {
+    const stringSecret = walletSecretToString(secret);
+    return encrypt(stringSecret, password);
+};
+
+export const isValidSK = (sk: string) => {
+    return /^[0-9a-fA-F]{128}$/.test(sk);
 };
 
 export const seeIfMnemonicValid = async (mnemonic: string[]) => {
diff --git a/packages/core/src/service/passwordService.ts b/packages/core/src/service/passwordService.ts
index 520f4aada..7eec4003b 100644
--- a/packages/core/src/service/passwordService.ts
+++ b/packages/core/src/service/passwordService.ts
@@ -2,8 +2,7 @@ import { IStorage } from '../Storage';
 import { AccountTonMnemonic, isMnemonicAndPassword } from '../entries/account';
 import { AuthPassword } from '../entries/password';
 import { AccountsStorage } from './accountsStorage';
-import { decrypt, encrypt } from './cryptoService';
-import { decryptWalletMnemonic, seeIfMnemonicValid } from './mnemonicService';
+import { decryptWalletSecret, encryptWalletSecret } from './mnemonicService';
 
 export class PasswordStorage {
     private readonly accountsStorage: AccountsStorage;
@@ -24,10 +23,8 @@ export class PasswordStorage {
                 throw new Error('None wallet has a password auth');
             }
 
-            const mnemonic = (
-                await decrypt((accToCheck.auth as AuthPassword).encryptedMnemonic, password)
-            ).split(' ');
-            return await seeIfMnemonicValid(mnemonic);
+            await decryptWalletSecret((accToCheck.auth as AuthPassword).encryptedSecret, password);
+            return true;
         } catch (e) {
             console.error(e);
             return false;
@@ -46,12 +43,12 @@ export class PasswordStorage {
 
         const updatedAccounts = await Promise.all(
             accounts.map(async acc => {
-                const mnemonic = await decryptWalletMnemonic(
-                    acc as { auth: AuthPassword },
+                const accountSecret = await decryptWalletSecret(
+                    (acc.auth as AuthPassword).encryptedSecret,
                     oldPassword
                 );
-                (acc.auth as AuthPassword).encryptedMnemonic = await encrypt(
-                    mnemonic.join(' '),
+                (acc.auth as AuthPassword).encryptedSecret = await encryptWalletSecret(
+                    accountSecret,
                     newPassword
                 );
                 return acc.clone();
diff --git a/packages/core/src/service/walletService.ts b/packages/core/src/service/walletService.ts
index bb222d26c..fc3a6118b 100644
--- a/packages/core/src/service/walletService.ts
+++ b/packages/core/src/service/walletService.ts
@@ -11,31 +11,32 @@ import {
     AccountMAM,
     AccountTonMnemonic,
     AccountTonMultisig,
-    AccountTonOnly,
+    AccountTonOnly, AccountTonSK,
     AccountTonTestnet,
     AccountTonWatchOnly
-} from '../entries/account';
+} from "../entries/account";
 import { APIConfig } from '../entries/apis';
 import { Network } from '../entries/network';
 import { AuthKeychain, AuthPassword, MnemonicType } from '../entries/password';
 import {
-    WalletVersion,
-    WalletVersions,
-    TonWalletStandard,
     DerivationItemNamed,
+    sortWalletsByVersion,
+    TonWalletStandard,
     WalletId,
-    sortWalletsByVersion
+    WalletVersion,
+    WalletVersions
 } from '../entries/wallet';
 import { AccountsApi, WalletApi } from '../tonApiV2';
 import { emojis } from '../utils/emojis';
 import { accountsStorage } from './accountsStorage';
 import { walletContract } from './wallet/contractService';
-import { TonKeychainRoot, KeychainTonAccount } from '@ton-keychain/core';
+import { KeychainTonAccount, TonKeychainRoot } from '@ton-keychain/core';
 import { mnemonicToKeypair } from './mnemonicService';
 import { FiatCurrencies } from '../entries/fiat';
 import { KeychainTrxAccountsProvider, TronAddressUtils } from '@ton-keychain/trx';
 import { TronWallet } from '../entries/tron/tron-wallet';
 import { ethers } from 'ethers';
+import { keyPairFromSecretKey } from '@ton/crypto';
 
 export const createMultisigTonAccount = async (
     storage: IStorage,
@@ -161,7 +162,7 @@ export const getContextApiByNetwork = (context: CreateWalletContext, network: Ne
     return api;
 };
 
-const createPayloadOfStandardTonAccount = async (
+const ]createPayloadOfStandardTonAccount = async (
     appContext: CreateWalletContext,
     storage: IStorage,
     mnemonic: string[],
@@ -264,6 +265,59 @@ export const createStandardTonAccountByMnemonic = async (
     });
 };
 
+export const createStandardTonAccountBySK = async (
+    appContext: CreateWalletContext,
+    storage: IStorage,
+    sk: string,
+    options: {
+        versions?: WalletVersion[];
+        auth: AuthPassword | Omit<AuthKeychain, 'keychainStoreKey'>;
+    }
+) => {
+    const keyPair = keyPairFromSecretKey(Buffer.from(sk, 'hex'));
+
+    const publicKey = keyPair.publicKey.toString('hex');
+
+    let tonWallets: { rawAddress: string; version: WalletVersion }[] = [];
+    if (options.versions) {
+        tonWallets = options.versions
+            .map(v => getWalletAddress(publicKey, v, Network.MAINNET))
+            .map(i => ({
+                rawAddress: i.address.toRawString(),
+                version: i.version
+            }));
+    } else {
+        tonWallets = [await findWalletAddress(appContext, Network.MAINNET, publicKey)];
+    }
+
+    let walletAuth: AuthPassword | AuthKeychain;
+    if (options.auth.kind === 'keychain') {
+        walletAuth = {
+            kind: 'keychain',
+            keychainStoreKey: publicKey
+        };
+    } else {
+        walletAuth = options.auth;
+    }
+
+    const { name, emoji } = await accountsStorage(storage).getNewAccountNameAndEmoji(publicKey);
+
+    const wallets = tonWallets
+        .slice()
+        .map(item => getTonWalletStandard(item, publicKey, Network.MAINNET));
+
+    const walletIdToActivate = wallets.slice().sort(sortWalletsByVersion)[0].id;
+
+    return AccountTonSK.create({
+        id: createAccountId(Network.MAINNET, publicKey),
+        name,
+        emoji,
+        auth: walletAuth,
+        activeTonWalletId: walletIdToActivate,
+        tonWallets: wallets
+    });
+};
+
 export const standardTonAccountToAccountWithTron = async (
     account: AccountTonMnemonic,
     getAccountMnemonic: () => Promise<string[]>
diff --git a/packages/locales/src/tonkeeper-web/en.json b/packages/locales/src/tonkeeper-web/en.json
index 6cff98d37..9fa267865 100644
--- a/packages/locales/src/tonkeeper-web/en.json
+++ b/packages/locales/src/tonkeeper-web/en.json
@@ -10,6 +10,7 @@
   "actionTitle": "Open the wallet",
   "activate": "Activate",
   "add": "Add",
+  "add_by_sk_title": "Account by private key",
   "add_dns_address": "Add wallet address that domain %1% will link to.",
   "add_wallet_existing_multisig_description": "%{number} wallets managed by your wallet list",
   "add_wallet_existing_multisig_title": "Existing Multisig Wallet",
@@ -333,6 +334,7 @@
   "settings_multisig_settings": "Multisig Settings",
   "show": "Show",
   "show_all": "Show All",
+  "sk_input_label": "Private key in hex format without 0x beginning. Length is 128 chars",
   "start_trial_notification_description": "Telegram connection is required solely for the purpose of verification that you are not a bot.",
   "start_trial_notification_heading": "Connect Telegram to Pro for Free",
   "swap_balance": "Balance",
@@ -422,6 +424,7 @@
   "txActions_USDT_transfer": "USDT Transfer",
   "Undo": "Undo",
   "Unexpected_QR_Code": "Unexpected QR Code",
+  "unknown_operation": "Unknown Operation",
   "Unlock": "Unlock",
   "update": "Update",
   "update_ledger_error": "Make sure your Ledger software is updated",
@@ -433,6 +436,7 @@
   "wallet_aside_collectibles": "Collectibles",
   "wallet_aside_domains": "Domains",
   "wallet_aside_history": "History",
+  "wallet_aside_home": "Home",
   "wallet_aside_multisig_wallets": "Multisig Wallets",
   "wallet_aside_orders": "Requests",
   "wallet_aside_purchases": "Purchases",
diff --git a/packages/locales/src/tonkeeper-web/ru-RU.json b/packages/locales/src/tonkeeper-web/ru-RU.json
index b074ff67c..c52cf6f7f 100644
--- a/packages/locales/src/tonkeeper-web/ru-RU.json
+++ b/packages/locales/src/tonkeeper-web/ru-RU.json
@@ -10,6 +10,7 @@
   "actionTitle": "Открыть Кошелек",
   "activate": "Активировать",
   "add": "Добавить",
+  "add_by_sk_title": "Аккаунт по приватному ключу",
   "add_dns_address": "Добавьте адрес кошелька, на который будет ссылаться домен %1%",
   "add_wallet_existing_multisig_description": "%{number} кошельков управляются вашим списком кошельков",
   "add_wallet_existing_multisig_title": "Существующий Multisig кошелек ",
@@ -322,6 +323,7 @@
   "settings_multisig_settings": "Настройки мультисиг-кошелька",
   "show": "Показать",
   "show_all": "Показать все",
+  "sk_input_label": "Закрытый ключ в hex формате без префикса 0x. Длина 128 символов",
   "start_trial_notification_description": "Подключение к Telegram необходимо только для проверки, что вы не бот.",
   "start_trial_notification_heading": "Подключите Telegram для пробного периода Pro",
   "swap_balance": "Баланс",
@@ -409,6 +411,7 @@
   "txActions_USDT_transfer": "Перевод USDT",
   "Undo": "Отменить",
   "Unexpected_QR_Code": "Неожиданный QR-код",
+  "unknown_operation": "Неизвестная операция",
   "Unlock": "Разблокировать",
   "update": "Обновить",
   "update_ledger_error": "Убедитесь, что программное обеспечение Ledger обновлено",
@@ -420,6 +423,7 @@
   "wallet_aside_collectibles": "Коллекции",
   "wallet_aside_domains": "Домены",
   "wallet_aside_history": "История",
+  "wallet_aside_home": "Главная",
   "wallet_aside_multisig_wallets": "Multisig кошельки",
   "wallet_aside_orders": "Заявки",
   "wallet_aside_purchases": "Покупки",
diff --git a/packages/uikit/src/components/account/AccountBadge.tsx b/packages/uikit/src/components/account/AccountBadge.tsx
index c3a42dfe7..f247e9a1f 100644
--- a/packages/uikit/src/components/account/AccountBadge.tsx
+++ b/packages/uikit/src/components/account/AccountBadge.tsx
@@ -200,7 +200,7 @@ export const AccountAndWalletBadgesGroup: FC<{
         return <AccountBadge className={className} size={size} accountType={account.type} />;
     }
 
-    if (account.type === 'mnemonic' || account.type === 'testnet') {
+    if (account.type === 'mnemonic' || account.type === 'testnet' || account.type === 'sk') {
         return null;
     }
 
diff --git a/packages/uikit/src/components/create/ChoseWalletVersions.tsx b/packages/uikit/src/components/create/ChoseWalletVersions.tsx
index 53bb41335..b887ea47d 100644
--- a/packages/uikit/src/components/create/ChoseWalletVersions.tsx
+++ b/packages/uikit/src/components/create/ChoseWalletVersions.tsx
@@ -66,18 +66,41 @@ const SubmitBlock = styled.div`
     width: 100%;
 `;
 
-export const ChoseWalletVersions: FC<{
+export const ChoseWalletVersionsByMnemonic: FC<{
     mnemonic: string[];
     mnemonicType: MnemonicType;
     network: Network;
     onSubmit: (versions: WalletVersion[]) => void;
     isLoading?: boolean;
 }> = ({ mnemonic, onSubmit, network, isLoading, mnemonicType }) => {
+    const [publicKey, setPublicKey] = useState<string | undefined>(undefined);
+
+    useEffect(() => {
+        mnemonicToKeypair(mnemonic, mnemonicType).then(keypair =>
+            setPublicKey(keypair.publicKey.toString('hex'))
+        );
+    }, [mnemonic]);
+
+    return (
+        <ChoseWalletVersions
+            network={network}
+            publicKey={publicKey}
+            onSubmit={onSubmit}
+            isLoading={isLoading}
+        />
+    );
+};
+
+export const ChoseWalletVersions: FC<{
+    publicKey: string | undefined;
+    network: Network;
+    onSubmit: (versions: WalletVersion[]) => void;
+    isLoading?: boolean;
+}> = ({ publicKey, onSubmit, network, isLoading }) => {
     const { t } = useTranslation();
     const sdk = useAppSdk();
     const { defaultWalletVersion } = useAppContext();
 
-    const [publicKey, setPublicKey] = useState<string | undefined>(undefined);
     const { data: wallets } = useStandardTonWalletVersions(network, publicKey);
     const [checkedVersions, setCheckedVersions] = useState<WalletVersion[]>([]);
     const accountState = useAccountState(mayBeCreateAccountId(network, publicKey));
@@ -88,12 +111,6 @@ export const ChoseWalletVersions: FC<{
         }
     }, []);
 
-    useEffect(() => {
-        mnemonicToKeypair(mnemonic, mnemonicType).then(keypair =>
-            setPublicKey(keypair.publicKey.toString('hex'))
-        );
-    }, [mnemonic]);
-
     useLayoutEffect(() => {
         if (wallets) {
             if (accountState && isAccountTonWalletStandard(accountState)) {
diff --git a/packages/uikit/src/components/create/SKInput.tsx b/packages/uikit/src/components/create/SKInput.tsx
new file mode 100644
index 000000000..113e0177e
--- /dev/null
+++ b/packages/uikit/src/components/create/SKInput.tsx
@@ -0,0 +1,83 @@
+import React, { FC, useEffect, useRef, useState } from 'react';
+import styled from 'styled-components';
+import { useTranslation } from '../../hooks/translation';
+import { CenterContainer } from '../Layout';
+import { H2Label2Responsive } from '../Text';
+import { ButtonResponsiveSize } from '../fields/Button';
+import { TextArea } from '../fields/Input';
+import { isValidSK } from '@tonkeeper/core/dist/service/mnemonicService';
+
+const Block = styled.div`
+    display: flex;
+    text-align: center;
+    gap: 1rem;
+    flex-direction: column;
+`;
+
+export const SKInput: FC<{
+    afterInput: (address: string) => void;
+    isLoading?: boolean;
+    className?: string;
+    onIsDirtyChange?: (isDirty: boolean) => void;
+}> = ({ afterInput, isLoading, className, onIsDirtyChange }) => {
+    const { t } = useTranslation();
+
+    const ref = useRef<HTMLTextAreaElement>(null);
+    const [sk, setSk] = useState<string>('');
+    const [error, setError] = useState<boolean>(false);
+    const [touched, setTouched] = useState<boolean>(false);
+
+    useEffect(() => {
+        onIsDirtyChange?.(!!sk);
+    }, [sk]);
+
+    useEffect(() => {
+        if (!touched) {
+            return;
+        }
+        if (!sk || !isValidSK(sk)) {
+            setError(true);
+        } else {
+            setError(false);
+        }
+    }, [touched, sk]);
+
+    useEffect(() => {
+        if (ref.current) {
+            ref.current.focus();
+        }
+    }, [ref]);
+
+    const onChange = (val: string) => {
+        setTouched(true);
+        setSk(val);
+    };
+
+    return (
+        <CenterContainer className={className}>
+            <Block>
+                <div>
+                    <H2Label2Responsive>{t('add_by_sk_title')}</H2Label2Responsive>
+                </div>
+                <TextArea
+                    id="secret-key"
+                    ref={ref}
+                    value={sk}
+                    onChange={onChange}
+                    isValid={!error}
+                    label={t('sk_input_label')}
+                />
+                <ButtonResponsiveSize
+                    fullWidth
+                    primary
+                    marginTop
+                    loading={isLoading}
+                    disabled={!sk || error}
+                    onClick={() => afterInput(sk!)}
+                >
+                    {t('continue')}
+                </ButtonResponsiveSize>
+            </Block>
+        </CenterContainer>
+    );
+};
diff --git a/packages/uikit/src/components/desktop/aside/AsideMenuAccount.tsx b/packages/uikit/src/components/desktop/aside/AsideMenuAccount.tsx
index e355c9fd8..2b850864e 100644
--- a/packages/uikit/src/components/desktop/aside/AsideMenuAccount.tsx
+++ b/packages/uikit/src/components/desktop/aside/AsideMenuAccount.tsx
@@ -18,8 +18,8 @@ import {
     AccountTonWatchOnly,
     Account,
     getNetworkByAccount,
-    AccountTonTestnet
-} from '@tonkeeper/core/dist/entries/account';
+    AccountTonTestnet, AccountTonSK
+} from "@tonkeeper/core/dist/entries/account";
 import { FC, forwardRef } from 'react';
 import { useIsHovered } from '../../../hooks/useIsHovered';
 import styled from 'styled-components';
@@ -125,7 +125,7 @@ const AsideMultisigItem = forwardRef<
 });
 
 export const AsideMenuAccountMnemonic: FC<{
-    account: AccountTonMnemonic | AccountTonTestnet;
+    account: AccountTonMnemonic | AccountTonTestnet | AccountTonSK;
     mightBeHighlighted: boolean;
     selectedWalletId: WalletId;
     onClickWallet: (walletId: WalletId) => void;
@@ -482,6 +482,7 @@ export const AsideMenuAccount: FC<{
     switch (account.type) {
         case 'mnemonic':
         case 'testnet':
+        case 'sk':
             return <AsideMenuAccountMnemonic account={account} {...rest} />;
         case 'ledger':
             return <AsideMenuAccountLedger account={account} {...rest} />;
diff --git a/packages/uikit/src/desktop-pages/settings/DesktopManageWalletsSettings.tsx b/packages/uikit/src/desktop-pages/settings/DesktopManageWalletsSettings.tsx
index b595e11c5..b25cd2d7b 100644
--- a/packages/uikit/src/desktop-pages/settings/DesktopManageWalletsSettings.tsx
+++ b/packages/uikit/src/desktop-pages/settings/DesktopManageWalletsSettings.tsx
@@ -30,6 +30,7 @@ import {
     AccountTonMnemonic,
     AccountTonMultisig,
     AccountTonOnly,
+    AccountTonSK,
     AccountTonTestnet,
     AccountTonWatchOnly
 } from '@tonkeeper/core/dist/entries/account';
@@ -332,7 +333,7 @@ const MultisigItemRow = forwardRef<
 });
 
 const AccountMnemonicRow: FC<{
-    account: AccountTonMnemonic | AccountTonTestnet;
+    account: AccountTonMnemonic | AccountTonTestnet | AccountTonSK;
     dragHandleProps?: DraggableProvidedDragHandleProps | null | undefined;
     tabLevel: number;
 }> = ({ account, dragHandleProps, tabLevel }) => {
@@ -687,6 +688,7 @@ const AccountRow: FC<{
     switch (account.type) {
         case 'mnemonic':
         case 'testnet':
+        case 'sk':
             return <AccountMnemonicRow account={account} {...rest} />;
         case 'ledger':
             return <AccountLedgerRow account={account} {...rest} />;
diff --git a/packages/uikit/src/pages/import/ImportBySKWallet.tsx b/packages/uikit/src/pages/import/ImportBySKWallet.tsx
new file mode 100644
index 000000000..8c5c17d53
--- /dev/null
+++ b/packages/uikit/src/pages/import/ImportBySKWallet.tsx
@@ -0,0 +1,182 @@
+import { Account, AccountTonSK } from '@tonkeeper/core/dist/entries/account';
+import React, { FC, useContext, useMemo, useState } from 'react';
+import { UpdateWalletName } from '../../components/create/WalletName';
+import {
+    useAccountsState,
+    useCreateAccountTonSK,
+    useMutateRenameAccount
+} from '../../state/wallet';
+import { FinalView } from './Password';
+import { useConfirmDiscardNotification } from '../../components/modals/ConfirmDiscardNotificationControlled';
+import { AddWalletContext } from '../../components/create/AddWalletContext';
+import {
+    OnCloseInterceptor,
+    useSetNotificationOnBack,
+    useSetNotificationOnCloseInterceptor
+} from '../../components/Notification';
+import { AccountIsAlreadyAdded } from '../../components/create/AccountIsAlreadyAdded';
+import { WalletId, WalletVersion } from '@tonkeeper/core/dist/entries/wallet';
+import { SKInput } from '../../components/create/SKInput';
+import { ChoseWalletVersions } from '../../components/create/ChoseWalletVersions';
+import { Network } from '@tonkeeper/core/dist/entries/network';
+import { createStandardTonAccountBySK } from '@tonkeeper/core/dist/service/walletService';
+import { useAppContext } from '../../hooks/appContext';
+import { useAppSdk } from '../../hooks/appSdk';
+import { useMutation } from '@tanstack/react-query';
+
+export const ImportBySKWallet: FC<{ afterCompleted: () => void }> = ({ afterCompleted }) => {
+    const { mutateAsync: createWalletsAsync, isLoading: isCreateWalletLoading } =
+        useCreateAccountTonSK();
+    const { mutateAsync: renameWallet, isLoading: renameLoading } = useMutateRenameAccount();
+
+    const [accountCandidate, setAccountCandidate] = useState<
+        { account: AccountTonSK; sk: string } | undefined
+    >(undefined);
+    const [createdAccount, setCreatedAccount] = useState<AccountTonSK | undefined>(undefined);
+
+    const [editNamePagePassed, setEditNamePagePassed] = useState(false);
+
+    const [isDirty, setIsDirty] = useState(false);
+
+    const { onOpen: openConfirmDiscard } = useConfirmDiscardNotification();
+    const { navigateHome } = useContext(AddWalletContext);
+    const onBack = useMemo(() => {
+        if (!accountCandidate) {
+            return undefined;
+        }
+        if (!createdAccount) {
+            if (!isDirty) {
+                return navigateHome;
+            }
+
+            return () =>
+                openConfirmDiscard({
+                    onClose: discard => {
+                        if (discard) {
+                            navigateHome?.();
+                        }
+                    }
+                });
+        }
+        return undefined;
+    }, [navigateHome, createdAccount, isDirty, openConfirmDiscard, accountCandidate]);
+    useSetNotificationOnBack(onBack);
+
+    const onCloseInterceptor = useMemo<OnCloseInterceptor>(() => {
+        if (!isDirty) {
+            return undefined;
+        }
+
+        if (createdAccount) {
+            return undefined;
+        }
+
+        return closeModal => {
+            openConfirmDiscard({
+                onClose: discard => {
+                    if (discard) {
+                        closeModal();
+                    }
+                }
+            });
+        };
+    }, [createdAccount, openConfirmDiscard, isDirty]);
+    useSetNotificationOnCloseInterceptor(onCloseInterceptor);
+
+    const [existingAccountAndWallet, setExistingAccountAndWallet] = useState<
+        | {
+              account: Account;
+              walletId: WalletId;
+          }
+        | undefined
+    >();
+    const accounts = useAccountsState();
+    const context = useAppContext();
+    const sdk = useAppSdk();
+
+    const { mutate: onSKSubmit, isLoading: isSubmitingSk } = useMutation(
+        async (secretKey: string) => {
+            const possibleAccount = await createStandardTonAccountBySK(
+                context,
+                sdk.storage,
+                secretKey,
+                {
+                    auth: {
+                        kind: 'keychain'
+                    },
+                    versions: [
+                        WalletVersion.V5R1,
+                        WalletVersion.V5_BETA,
+                        WalletVersion.V4R2,
+                        WalletVersion.V3R2,
+                        WalletVersion.V3R1
+                    ]
+                }
+            );
+
+            const existingAccount = accounts.find(a => a.id === possibleAccount.id);
+            if (existingAccount) {
+                setExistingAccountAndWallet({
+                    account: existingAccount,
+                    walletId: existingAccount.activeTonWallet.id
+                });
+                return;
+            }
+            setAccountCandidate({ account: possibleAccount, sk: secretKey });
+        }
+    );
+
+    if (existingAccountAndWallet) {
+        return (
+            <AccountIsAlreadyAdded {...existingAccountAndWallet} onOpenAccount={afterCompleted} />
+        );
+    }
+
+    if (!accountCandidate) {
+        return (
+            <SKInput
+                afterInput={onSKSubmit}
+                isLoading={isSubmitingSk}
+                onIsDirtyChange={setIsDirty}
+            />
+        );
+    }
+
+    if (!createdAccount) {
+        return (
+            <ChoseWalletVersions
+                network={Network.MAINNET}
+                publicKey={accountCandidate.account.activeTonWallet.publicKey}
+                onSubmit={versions => {
+                    createWalletsAsync({
+                        sk: accountCandidate.sk,
+                        versions,
+                        selectAccount: true
+                    }).then(setCreatedAccount);
+                }}
+                isLoading={isCreateWalletLoading}
+            />
+        );
+    }
+
+    if (!editNamePagePassed) {
+        return (
+            <UpdateWalletName
+                name={createdAccount.name}
+                submitHandler={val => {
+                    renameWallet({
+                        id: createdAccount.id,
+                        ...val
+                    }).then(newAcc => {
+                        setEditNamePagePassed(true);
+                        setCreatedAccount(newAcc as AccountTonSK);
+                    });
+                }}
+                walletEmoji={createdAccount.emoji}
+                isLoading={renameLoading}
+            />
+        );
+    }
+
+    return <FinalView afterCompleted={afterCompleted} />;
+};
diff --git a/packages/uikit/src/pages/import/ImportExistingWallet.tsx b/packages/uikit/src/pages/import/ImportExistingWallet.tsx
index 21862d05b..66a4d5dac 100644
--- a/packages/uikit/src/pages/import/ImportExistingWallet.tsx
+++ b/packages/uikit/src/pages/import/ImportExistingWallet.tsx
@@ -11,7 +11,7 @@ import {
     useMutateRenameAccount,
     useMutateRenameAccountDerivations
 } from '../../state/wallet';
-import { ChoseWalletVersions } from '../../components/create/ChoseWalletVersions';
+import { ChoseWalletVersions, ChoseWalletVersionsByMnemonic } from "../../components/create/ChoseWalletVersions";
 import {
     AccountMAM,
     AccountTonMnemonic,
@@ -430,7 +430,7 @@ export const ImportExistingWallet: FC<{ afterCompleted: () => void }> = ({ after
 
     if (!createdAccount) {
         return (
-            <ChoseWalletVersions
+            <ChoseWalletVersionsByMnemonic
                 network={Network.MAINNET}
                 mnemonic={mnemonic}
                 mnemonicType={selectedMnemonicType === 'tonMnemonic' ? 'ton' : 'bip39'}
diff --git a/packages/uikit/src/pages/import/ImportTestnetWallet.tsx b/packages/uikit/src/pages/import/ImportTestnetWallet.tsx
index 983702ba7..310fb448e 100644
--- a/packages/uikit/src/pages/import/ImportTestnetWallet.tsx
+++ b/packages/uikit/src/pages/import/ImportTestnetWallet.tsx
@@ -9,7 +9,7 @@ import {
     useCreateAccountTestnet,
     useMutateRenameAccount
 } from '../../state/wallet';
-import { ChoseWalletVersions } from '../../components/create/ChoseWalletVersions';
+import { ChoseWalletVersions, ChoseWalletVersionsByMnemonic } from "../../components/create/ChoseWalletVersions";
 import { AccountTonTestnet, getAccountByWalletById } from '@tonkeeper/core/dist/entries/account';
 import {
     createStandardTestnetAccountByMnemonic,
@@ -143,7 +143,7 @@ export const ImportTestnetWallet: FC<{ afterCompleted: () => void }> = ({ afterC
     };
 
     const onRename = async (form: { name: string; emoji: string }) => {
-        let newAcc: AccountTonTestnet = await renameAccount({
+        const newAcc: AccountTonTestnet = await renameAccount({
             id: createdAccount!.id,
             ...form
         });
@@ -234,7 +234,7 @@ export const ImportTestnetWallet: FC<{ afterCompleted: () => void }> = ({ afterC
 
     if (!createdAccount) {
         return (
-            <ChoseWalletVersions
+            <ChoseWalletVersionsByMnemonic
                 network={Network.TESTNET}
                 mnemonic={mnemonic}
                 mnemonicType={'ton'}
diff --git a/packages/uikit/src/pages/settings/Dev.tsx b/packages/uikit/src/pages/settings/Dev.tsx
index 85d61e0f1..e76e0089d 100644
--- a/packages/uikit/src/pages/settings/Dev.tsx
+++ b/packages/uikit/src/pages/settings/Dev.tsx
@@ -13,6 +13,10 @@ import { Badge } from '../../components/shared';
 import styled from 'styled-components';
 import { useDevSettings, useMutateDevSettings } from '../../state/dev';
 import { useActiveConfig } from '../../state/wallet';
+import { useDisclosure } from '../../hooks/useDisclosure';
+import { Notification } from '../../components/Notification';
+import { ImportBySKWallet } from '../import/ImportBySKWallet';
+import { Button } from '../../components/fields/Button';
 
 const CookieSettings = () => {
     const sdk = useAppSdk();
@@ -116,6 +120,21 @@ const EnableTronSettings = () => {
     );
 };
 
+const AddAccountBySK = () => {
+    const { isOpen, onClose, onOpen } = useDisclosure();
+
+    return (
+        <>
+            <Button onClick={onOpen} primary>
+                Add account with private key
+            </Button>
+            <Notification isOpen={isOpen} handleClose={onClose}>
+                {() => <ImportBySKWallet afterCompleted={onClose} />}
+            </Notification>
+        </>
+    );
+};
+
 export const DevSettings = React.memo(() => {
     return (
         <>
@@ -124,6 +143,7 @@ export const DevSettings = React.memo(() => {
                 <EnableTwoFASettings />
                 <EnableTronSettings />
                 <CookieSettings />
+                <AddAccountBySK />
             </InnerBody>
         </>
     );
diff --git a/packages/uikit/src/pages/settings/Recovery.tsx b/packages/uikit/src/pages/settings/Recovery.tsx
index b9d017073..698258ba7 100644
--- a/packages/uikit/src/pages/settings/Recovery.tsx
+++ b/packages/uikit/src/pages/settings/Recovery.tsx
@@ -1,5 +1,6 @@
 import {
     AccountId,
+    AccountSecret,
     isAccountBip39,
     isAccountTronCompatible,
     isMnemonicAndPassword
@@ -11,7 +12,7 @@ import styled, { css } from 'styled-components';
 import { BackButtonBlock } from '../../components/BackButton';
 import { WordsGridAndHeaders } from '../../components/create/Words';
 import { useAppSdk } from '../../hooks/appSdk';
-import { getAccountMnemonic, getMAMWalletMnemonic } from '../../state/mnemonic';
+import { getAccountSecret, getMAMWalletMnemonic } from '../../state/mnemonic';
 import { useCheckTouchId } from '../../state/password';
 import { useAccountState, useActiveAccount } from '../../state/wallet';
 import { Body2Class } from '../../components/Text';
@@ -19,6 +20,7 @@ import { useTranslation } from '../../hooks/translation';
 import { tonMnemonicToTronMnemonic } from '@tonkeeper/core/dist/service/walletService';
 import { SpinnerRing } from '../../components/Icon';
 import { useSetNotificationOnBack } from '../../components/Notification';
+import { BorderSmallResponsive } from '../../components/shared/Styles';
 
 export const ActiveRecovery = () => {
     const account = useActiveAccount();
@@ -43,28 +45,31 @@ export const Recovery = () => {
     }
 };
 
-const useMnemonic = (onBack: () => void, accountId: AccountId, walletId?: WalletId) => {
-    const [mnemonic, setMnemonic] = useState<string[] | undefined>(undefined);
+const useSecret = (onBack: () => void, accountId: AccountId, walletId?: WalletId) => {
+    const [secret, setSecret] = useState<AccountSecret | undefined>(undefined);
     const sdk = useAppSdk();
     const { mutateAsync: checkTouchId } = useCheckTouchId();
 
     useEffect(() => {
         (async () => {
             try {
-                let _mnemonic;
+                let _secret;
                 if (walletId !== undefined) {
-                    _mnemonic = await getMAMWalletMnemonic(sdk, accountId, walletId, checkTouchId);
+                    _secret = {
+                        type: 'mnemonic' as const,
+                        mnemonic: await getMAMWalletMnemonic(sdk, accountId, walletId, checkTouchId)
+                    };
                 } else {
-                    _mnemonic = await getAccountMnemonic(sdk, accountId, checkTouchId);
+                    _secret = await getAccountSecret(sdk, accountId, checkTouchId);
                 }
-                setMnemonic(_mnemonic);
+                setSecret(_secret);
             } catch (e) {
                 onBack();
             }
         })();
     }, [onBack, accountId, checkTouchId, walletId]);
 
-    return mnemonic;
+    return secret;
 };
 
 const Wrapper = styled.div`
@@ -100,6 +105,24 @@ const SpinnerRingStyled = styled(SpinnerRing)`
     margin: 16px auto;
 `;
 
+const mnemonicBySecret = (secret: AccountSecret | undefined) => {
+    if (secret?.type === 'mnemonic') {
+        return secret.mnemonic;
+    }
+
+    return undefined;
+};
+
+const SKWrapper = styled.div`
+    margin: 1rem;
+    padding: 1rem;
+    ${BorderSmallResponsive};
+    ${Body2Class};
+    background: ${p => p.theme.backgroundContent};
+    font-family: ${p => p.theme.fontMono};
+    word-break: break-all;
+`;
+
 export const RecoveryContent: FC<{
     accountId: AccountId;
     walletId?: WalletId;
@@ -110,17 +133,17 @@ export const RecoveryContent: FC<{
     const navigate = useNavigate();
     const onBack = useCallback(() => (onClose ? onClose() : navigate(-1)), [onClose, navigate]);
 
-    const mnemonic = useMnemonic(onBack, accountId, walletId);
+    const secret = useSecret(onBack, accountId, walletId);
     const account = useAccountState(accountId);
     const [isExportingTRC20, setIsExportingTrc20] = useState(false);
 
-    const [mnemonicToShow, setMnemonicToShow] = useState(mnemonic);
+    const [mnemonicToShow, setMnemonicToShow] = useState(mnemonicBySecret(secret));
     useEffect(() => {
-        setMnemonicToShow(mnemonic);
-    }, [mnemonic]);
+        setMnemonicToShow(mnemonicBySecret(secret));
+    }, [secret]);
 
     const onHideTron = () => {
-        setMnemonicToShow(mnemonic);
+        setMnemonicToShow(mnemonicBySecret(secret));
         setIsExportingTrc20(false);
     };
 
@@ -141,7 +164,7 @@ export const RecoveryContent: FC<{
         !isAccountBip39(account);
 
     const onShowTron = async () => {
-        const tronMnemonic = await tonMnemonicToTronMnemonic(mnemonic!);
+        const tronMnemonic = await tonMnemonicToTronMnemonic(mnemonicBySecret(secret)!);
         setMnemonicToShow(tronMnemonic);
         setIsExportingTrc20(true);
     };
@@ -153,6 +176,15 @@ export const RecoveryContent: FC<{
             ? 'tron'
             : 'standard';
 
+    if (secret?.type === 'sk') {
+        return (
+            <Wrapper>
+                <BackButtonBlockStyled onClick={onBack} />
+                <SKWrapper>{secret.sk}</SKWrapper>
+            </Wrapper>
+        );
+    }
+
     return (
         <Wrapper>
             {isPage && <BackButtonBlockStyled onClick={onBack} />}
diff --git a/packages/uikit/src/state/mnemonic.ts b/packages/uikit/src/state/mnemonic.ts
index 3fdba25e0..8d0e319ce 100644
--- a/packages/uikit/src/state/mnemonic.ts
+++ b/packages/uikit/src/state/mnemonic.ts
@@ -1,12 +1,13 @@
 import { TonKeychainRoot } from '@ton-keychain/core';
 import { Cell } from '@ton/core';
-import { sha256_sync, sign } from '@ton/crypto';
+import { keyPairFromSecretKey, sha256_sync, sign } from '@ton/crypto';
 import { IAppSdk } from '@tonkeeper/core/dist/AppSdk';
 import {
     AccountId,
     isAccountTronCompatible,
     isMnemonicAndPassword,
-    Account
+    Account,
+    AccountSecret
 } from '@tonkeeper/core/dist/entries/account';
 import { AuthPassword, MnemonicType } from '@tonkeeper/core/dist/entries/password';
 import { CellSigner, Signer, TronSigner } from '@tonkeeper/core/dist/entries/signer';
@@ -19,8 +20,9 @@ import {
     LedgerTransaction
 } from '@tonkeeper/core/dist/service/ledger/connector';
 import {
-    decryptWalletMnemonic,
-    mnemonicToKeypair
+    decryptWalletSecret,
+    mnemonicToKeypair,
+    walletSecretFromString
 } from '@tonkeeper/core/dist/service/mnemonicService';
 import {
     parseSignerSignature,
@@ -80,8 +82,11 @@ export const signTonConnectOver = ({
             }
             case 'testnet':
             case 'mnemonic': {
-                const mnemonic = await getAccountMnemonic(sdk, accountId, checkTouchId);
-                const keyPair = await mnemonicToKeypair(mnemonic, account.mnemonicType);
+                const secret = await getAccountSecret(sdk, accountId, checkTouchId);
+                if (secret.type !== 'mnemonic') {
+                    throw new Error('Unexpected secret type');
+                }
+                const keyPair = await mnemonicToKeypair(secret.mnemonic, account.mnemonicType);
                 return nacl.sign.detached(
                     Buffer.from(sha256_sync(bufferToSign)),
                     keyPair.secretKey
@@ -96,6 +101,17 @@ export const signTonConnectOver = ({
                     keyPair.secretKey
                 );
             }
+            case 'sk': {
+                const secret = await getAccountSecret(sdk, accountId, checkTouchId);
+                if (secret.type !== 'sk') {
+                    throw new Error('Unexpected secret type');
+                }
+                const keyPair = keyPairFromSecretKey(Buffer.from(secret.sk, 'hex'));
+                return nacl.sign.detached(
+                    Buffer.from(sha256_sync(bufferToSign)),
+                    keyPair.secretKey
+                );
+            }
             case 'watch-only': {
                 throw new TxConfirmationCustomError("Can't use tonconnect over watch-only wallet");
             }
@@ -237,9 +253,24 @@ export const getSigner = async (
             }
             case 'testnet':
             case 'mnemonic': {
-                const mnemonic = await getAccountMnemonic(sdk, account.id, checkTouchId);
+                const secret = await getAccountSecret(sdk, account.id, checkTouchId);
+                if (secret.type !== 'mnemonic') {
+                    throw new Error('Unexpected secret type');
+                }
+                const callback = async (message: Cell) => {
+                    const keyPair = await mnemonicToKeypair(secret.mnemonic, account.mnemonicType);
+                    return sign(message.hash(), keyPair.secretKey);
+                };
+                callback.type = 'cell' as const;
+                return callback;
+            }
+            case 'sk': {
+                const secret = await getAccountSecret(sdk, accountId, checkTouchId);
+                if (secret.type !== 'sk') {
+                    throw new Error('Unexpected secret type');
+                }
                 const callback = async (message: Cell) => {
-                    const keyPair = await mnemonicToKeypair(mnemonic, account.mnemonicType);
+                    const keyPair = keyPairFromSecretKey(Buffer.from(secret.sk, 'hex'));
                     return sign(message.hash(), keyPair.secretKey);
                 };
                 callback.type = 'cell' as const;
@@ -299,7 +330,11 @@ export const getTronSigner = (
             }
             case 'mnemonic': {
                 return async (tx: Transaction) => {
-                    const tonMnemonic = await getAccountMnemonic(sdk, account.id, checkTouchId);
+                    const secret = await getAccountSecret(sdk, account.id, checkTouchId);
+                    if (secret.type !== 'mnemonic') {
+                        throw new Error('Unexpected secret type');
+                    }
+                    const tonMnemonic = secret.mnemonic;
                     const tronMnemonic = await tonMnemonicToTronMnemonic(
                         tonMnemonic,
                         account.mnemonicType
@@ -323,13 +358,13 @@ export const getTronSigner = (
     }
 };
 
-export const getAccountMnemonic = async (
+export const getAccountSecret = async (
     sdk: IAppSdk,
     accountId: AccountId,
     checkTouchId: () => Promise<void>
-): Promise<string[]> => {
-    const { mnemonic } = await getMnemonicAndPassword(sdk, accountId, checkTouchId);
-    return mnemonic;
+): Promise<AccountSecret> => {
+    const { secret } = await getSecretAndPassword(sdk, accountId, checkTouchId);
+    return secret;
 };
 
 export const getMAMWalletMnemonic = async (
@@ -347,17 +382,20 @@ export const getMAMWalletMnemonic = async (
         throw new Error('Derivation not found');
     }
 
-    const { mnemonic } = await getMnemonicAndPassword(sdk, accountId, checkTouchId);
-    const root = await TonKeychainRoot.fromMnemonic(mnemonic, { allowLegacyMnemonic: true });
+    const { secret } = await getSecretAndPassword(sdk, accountId, checkTouchId);
+    if (secret.type !== 'mnemonic') {
+        throw new Error('Unexpected secret type');
+    }
+    const root = await TonKeychainRoot.fromMnemonic(secret.mnemonic, { allowLegacyMnemonic: true });
     const tonAccount = await root.getTonAccount(derivation.index);
     return tonAccount.mnemonics;
 };
 
-export const getMnemonicAndPassword = async (
+export const getSecretAndPassword = async (
     sdk: IAppSdk,
     accountId: AccountId,
     checkTouchId: () => Promise<void>
-): Promise<{ mnemonic: string[]; password?: string }> => {
+): Promise<{ secret: AccountSecret; password?: string }> => {
     const account = await accountsStorage(sdk.storage).getAccount(accountId);
     if (!account || !isMnemonicAndPassword(account) || !('auth' in account)) {
         throw new Error('Unexpected auth method for account');
@@ -366,13 +404,13 @@ export const getMnemonicAndPassword = async (
     switch (account.auth.kind) {
         case 'password': {
             const password = await getPasswordByNotification(sdk);
-            const mnemonic = await decryptWalletMnemonic(
-                account as { auth: AuthPassword },
+            const secret = await decryptWalletSecret(
+                (account.auth as AuthPassword).encryptedSecret,
                 password
             );
             return {
                 password,
-                mnemonic
+                secret
             };
         }
         case 'keychain': {
@@ -381,8 +419,8 @@ export const getMnemonicAndPassword = async (
             }
             await checkTouchId();
 
-            const mnemonic = await sdk.keychain.getPassword(account.auth.keychainStoreKey);
-            return { mnemonic: mnemonic.split(' ') };
+            const secret = await sdk.keychain.getPassword(account.auth.keychainStoreKey);
+            return { secret: await walletSecretFromString(secret) };
         }
         default:
             throw new Error('Unexpected auth method');
@@ -576,13 +614,13 @@ const pairLedgerByNotification = async <T extends 'transaction' | 'ton-proof'>(
     );
 };
 
-export const useGetActiveAccountMnemonic = () => {
+export const useGetActiveAccountSecret = () => {
     const sdk = useAppSdk();
     const { mutateAsync: checkTouchId } = useCheckTouchId();
     const activeAccount = useActiveAccount();
     const accountId = activeAccount.id;
 
     return useCallback(async () => {
-        return getAccountMnemonic(sdk, accountId, checkTouchId);
+        return getAccountSecret(sdk, accountId, checkTouchId);
     }, [sdk, checkTouchId, accountId]);
 };
diff --git a/packages/uikit/src/state/wallet.ts b/packages/uikit/src/state/wallet.ts
index 48bfe636c..a9c690ad8 100644
--- a/packages/uikit/src/state/wallet.ts
+++ b/packages/uikit/src/state/wallet.ts
@@ -4,9 +4,12 @@ import {
     Account,
     AccountId,
     AccountMAM,
+    AccountSecretMnemonic,
+    AccountSecretSK,
     AccountsState,
     AccountTonMnemonic,
     AccountTonMultisig,
+    AccountTonSK,
     AccountTonTestnet,
     AccountTonWatchOnly,
     getAccountByWalletById,
@@ -26,7 +29,6 @@ import {
     WalletId,
     WalletVersion
 } from '@tonkeeper/core/dist/entries/wallet';
-import { encrypt } from '@tonkeeper/core/dist/service/cryptoService';
 import {
     getActiveWalletConfig,
     setActiveWalletConfig
@@ -38,6 +40,7 @@ import {
     createReadOnlyTonAccountByAddress,
     createStandardTestnetAccountByMnemonic,
     createStandardTonAccountByMnemonic,
+    createStandardTonAccountBySK,
     getContextApiByNetwork,
     getStandardTonWalletVersions,
     getTonWalletStandard,
@@ -53,13 +56,13 @@ import { useAppContext } from '../hooks/appContext';
 import { useAppSdk } from '../hooks/appSdk';
 import { useAccountsStorage } from '../hooks/useStorage';
 import { anyOfKeysParts, QueryKey } from '../libs/queryKey';
-import {
-    getAccountMnemonic,
-    getPasswordByNotification,
-    useGetActiveAccountMnemonic
-} from './mnemonic';
+import { getAccountSecret, getPasswordByNotification, useGetActiveAccountSecret } from './mnemonic';
 import { useCheckTouchId } from './password';
-import { seeIfMnemonicValid } from '@tonkeeper/core/dist/service/mnemonicService';
+import {
+    encryptWalletSecret,
+    seeIfMnemonicValid,
+    walletSecretToString
+} from '@tonkeeper/core/dist/service/mnemonicService';
 import { useAccountsStateQuery, useAccountsState } from './accounts';
 import { useGlobalPreferences } from './global-preferences';
 import { useDeleteFolder } from './folders';
@@ -226,7 +229,11 @@ export const useCreateMAMAccountDerivation = () => {
         }
         const newDerivationIndex = account.lastAddedIndex + 1;
 
-        const mnemonic = await getAccountMnemonic(sdk, accountId, checkTouchId);
+        const secret = await getAccountSecret(sdk, accountId, checkTouchId);
+        if (secret.type !== 'mnemonic') {
+            throw new Error('Unexpected secret type');
+        }
+        const mnemonic = secret.mnemonic;
 
         const root = await TonKeychainRoot.fromMnemonic(mnemonic, { allowLegacyMnemonic: true });
         const tonAccount = await root.getTonAccount(newDerivationIndex);
@@ -419,6 +426,11 @@ export const useCreateAccountTestnet = () => {
             selectAccount?: boolean;
         }
     >(async ({ mnemonic, password, versions, selectAccount, mnemonicType }) => {
+        const accountSecret: AccountSecretMnemonic = {
+            type: 'mnemonic',
+            mnemonic
+        };
+
         const valid = await seeIfMnemonicValid(mnemonic);
         if (!valid) {
             throw new Error('Mnemonic is not valid.');
@@ -440,7 +452,7 @@ export const useCreateAccountTestnet = () => {
 
             await sdk.keychain.setPassword(
                 (account.auth as AuthKeychain).keychainStoreKey,
-                mnemonic.join(' ')
+                walletSecretToString(accountSecret)
             );
 
             await addAccountToState(account);
@@ -454,7 +466,6 @@ export const useCreateAccountTestnet = () => {
             password = await getPasswordByNotification(sdk);
         }
 
-        const encryptedMnemonic = await encrypt(mnemonic.join(' '), password);
         const account = await createStandardTestnetAccountByMnemonic(
             context,
             sdk.storage,
@@ -463,7 +474,7 @@ export const useCreateAccountTestnet = () => {
             {
                 auth: {
                     kind: 'password',
-                    encryptedMnemonic
+                    encryptedSecret: await encryptWalletSecret(accountSecret, password)
                 },
                 versions
             }
@@ -478,11 +489,19 @@ export const useCreateAccountTestnet = () => {
 };
 
 export const useAddTronToAccount = () => {
-    const getMnemonic = useGetActiveAccountMnemonic();
+    const getSecret = useGetActiveAccountSecret();
     const activeAccount = useActiveAccount();
     const accountsStorage = useAccountsStorage();
     const client = useQueryClient();
 
+    const getMnemonic = async () => {
+        const secret = await getSecret();
+        if (secret.type !== 'mnemonic') {
+            throw new Error('Unexpected secret type');
+        }
+        return secret.mnemonic;
+    };
+
     return useMutation(async () => {
         if (!isAccountTronCompatible(activeAccount)) {
             throw new Error('Account is not tron compatible');
@@ -526,6 +545,10 @@ export const useCreateAccountMnemonic = () => {
             selectAccount?: boolean;
         }
     >(async ({ mnemonic, password, versions, selectAccount, mnemonicType }) => {
+        const accountSecret: AccountSecretMnemonic = {
+            type: 'mnemonic',
+            mnemonic
+        };
         const valid = await seeIfMnemonicValid(mnemonic);
         if (!valid) {
             throw new Error('Mnemonic is not valid.');
@@ -548,7 +571,7 @@ export const useCreateAccountMnemonic = () => {
 
             await sdk.keychain.setPassword(
                 (account.auth as AuthKeychain).keychainStoreKey,
-                mnemonic.join(' ')
+                walletSecretToString(accountSecret)
             );
 
             await addAccountToState(account);
@@ -562,7 +585,6 @@ export const useCreateAccountMnemonic = () => {
             password = await getPasswordByNotification(sdk);
         }
 
-        const encryptedMnemonic = await encrypt(mnemonic.join(' '), password);
         const account = await createStandardTonAccountByMnemonic(
             context,
             sdk.storage,
@@ -571,7 +593,7 @@ export const useCreateAccountMnemonic = () => {
             {
                 auth: {
                     kind: 'password',
-                    encryptedMnemonic
+                    encryptedSecret: await encryptWalletSecret(accountSecret, password)
                 },
                 versions,
                 generateTronWallet: isTronEnabled
@@ -586,6 +608,67 @@ export const useCreateAccountMnemonic = () => {
     });
 };
 
+export const useCreateAccountTonSK = () => {
+    const sdk = useAppSdk();
+    const context = useAppContext();
+    const { mutateAsync: addAccountToState } = useAddAccountToStateMutation();
+    const { mutateAsync: selectAccountMutation } = useMutateActiveAccount();
+
+    return useMutation<
+        AccountTonSK,
+        Error,
+        {
+            sk: string;
+            password?: string;
+            versions: WalletVersion[];
+            selectAccount?: boolean;
+        }
+    >(async ({ sk, password, versions, selectAccount }) => {
+        const accountSecret: AccountSecretSK = {
+            type: 'sk',
+            sk
+        };
+        if (sdk.keychain) {
+            const account = await createStandardTonAccountBySK(context, sdk.storage, sk, {
+                auth: {
+                    kind: 'keychain'
+                },
+                versions
+            });
+
+            await sdk.keychain.setPassword(
+                (account.auth as AuthKeychain).keychainStoreKey,
+                walletSecretToString(accountSecret)
+            );
+
+            await addAccountToState(account);
+            if (selectAccount) {
+                await selectAccountMutation(account.id);
+            }
+            return account;
+        }
+
+        if (!password) {
+            password = await getPasswordByNotification(sdk);
+        }
+
+        const encryptedSK = await encryptWalletSecret(accountSecret, password);
+        const account = await createStandardTonAccountBySK(context, sdk.storage, sk, {
+            auth: {
+                kind: 'password',
+                encryptedSecret: encryptedSK
+            },
+            versions
+        });
+
+        await addAccountToState(account);
+        if (selectAccount) {
+            await selectAccountMutation(account.id);
+        }
+        return account;
+    });
+};
+
 export const useCreateAccountMAM = () => {
     const sdk = useAppSdk();
     const context = useAppContext();
@@ -603,6 +686,11 @@ export const useCreateAccountMAM = () => {
             selectAccount?: boolean;
         }
     >(async ({ selectedDerivations, mnemonic, password, selectAccount }) => {
+        const accountSecret: AccountSecretMnemonic = {
+            type: 'mnemonic',
+            mnemonic
+        };
+
         if (sdk.keychain) {
             const account = await createMAMAccountByMnemonic(context, sdk.storage, mnemonic, {
                 selectedDerivations,
@@ -614,7 +702,7 @@ export const useCreateAccountMAM = () => {
 
             await sdk.keychain.setPassword(
                 (account.auth as AuthKeychain).keychainStoreKey,
-                mnemonic.join(' ')
+                walletSecretToString(accountSecret)
             );
 
             await addAccountToState(account);
@@ -628,12 +716,11 @@ export const useCreateAccountMAM = () => {
             password = await getPasswordByNotification(sdk);
         }
 
-        const encryptedMnemonic = await encrypt(mnemonic.join(' '), password);
         const account = await createMAMAccountByMnemonic(context, sdk.storage, mnemonic, {
             selectedDerivations,
             auth: {
                 kind: 'password',
-                encryptedMnemonic
+                encryptedSecret: await encryptWalletSecret(accountSecret, password)
             },
             generateTronWallet: isTronEnabled
         });