@subwallet/extension-base 1.2.31-0 → 1.2.33-0

package/koni/background/handlers/Extension.js

@@ -6,8 +6,8 @@ import { LegacyTransaction } from '@ethereumjs/tx';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { withErrorLog } from '@subwallet/extension-base/background/handlers/helpers';
 import { createSubscription } from '@subwallet/extension-base/background/handlers/subscriptions';
-import { AccountExternalErrorCode, BasicTxErrorType, CampaignDataType, ChainType, ExternalRequestPromiseStatus, ExtrinsicType, MantaPayEnableMessage, StakingTxErrorType, StakingType } from '@subwallet/extension-base/background/KoniTypes';
-import { ALL_ACCOUNT_KEY, ALL_GENESIS_HASH, LATEST_SESSION, XCM_FEE_RATIO } from '@subwallet/extension-base/constants';
+import { CampaignDataType, ChainType, ExternalRequestPromiseStatus, ExtrinsicType, MantaPayEnableMessage, StakingType } from '@subwallet/extension-base/background/KoniTypes';
+import { ALL_ACCOUNT_KEY, LATEST_SESSION, XCM_FEE_RATIO } from '@subwallet/extension-base/constants';
 import { additionalValidateTransfer, additionalValidateXcmTransfer, validateTransferRequest, validateXcmTransferRequest } from '@subwallet/extension-base/core/logic-validation/transfer';
 import { _isSnowBridgeXcm } from '@subwallet/extension-base/core/substrate/xcm-parser';
 import { ALLOWED_PATH } from '@subwallet/extension-base/defaults';
@@ -21,54 +21,34 @@ import { getBondingExtrinsic, getCancelWithdrawalExtrinsic, getClaimRewardExtrin
 import { getTuringCancelCompoundingExtrinsic, getTuringCompoundExtrinsic } from '@subwallet/extension-base/koni/api/staking/bonding/paraChain';
 import { getPoolingBondingExtrinsic, getPoolingUnbondingExtrinsic, validatePoolBondingCondition, validateRelayUnbondingCondition } from '@subwallet/extension-base/koni/api/staking/bonding/relayChain';
 import { YIELD_EXTRINSIC_TYPES } from '@subwallet/extension-base/koni/api/yield/helper/utils';
+import { isBounceableAddress } from '@subwallet/extension-base/services/balance-service/helpers/subscribe/ton/utils';
 import { getERC20TransactionObject, getERC721Transaction, getEVMTransactionObject, getPSP34TransferExtrinsic } from '@subwallet/extension-base/services/balance-service/transfer/smart-contract';
 import { createTransferExtrinsic, getTransferMockTxFee } from '@subwallet/extension-base/services/balance-service/transfer/token';
+import { createTonTransaction } from '@subwallet/extension-base/services/balance-service/transfer/ton-transfer';
 import { createSnowBridgeExtrinsic, createXcmExtrinsic, getXcmMockTxFee } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
 import { _API_OPTIONS_CHAIN_GROUP, _DEFAULT_MANTA_ZK_CHAIN, _MANTA_ZK_CHAIN_GROUP, _ZK_ASSET_PREFIX } from '@subwallet/extension-base/services/chain-service/constants';
 import { _ChainConnectionStatus } from '@subwallet/extension-base/services/chain-service/types';
-import { _getAssetDecimals, _getAssetSymbol, _getChainNativeTokenBasicInfo, _getContractAddressOfToken, _getEvmChainId, _getSubstrateGenesisHash, _isAssetSmartContractNft, _isChainEvmCompatible, _isCustomAsset, _isLocalToken, _isMantaZkAsset, _isNativeToken, _isPureEvmChain, _isTokenEvmSmartContract, _isTokenTransferredByEvm } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getAssetDecimals, _getAssetSymbol, _getChainNativeTokenBasicInfo, _getContractAddressOfToken, _getEvmChainId, _isAssetSmartContractNft, _isChainEvmCompatible, _isChainTonCompatible, _isCustomAsset, _isLocalToken, _isMantaZkAsset, _isNativeToken, _isPureEvmChain, _isTokenEvmSmartContract, _isTokenTransferredByEvm, _isTokenTransferredByTon } from '@subwallet/extension-base/services/chain-service/utils';
 import { EXTENSION_REQUEST_URL } from '@subwallet/extension-base/services/request-service/constants';
 import { DEFAULT_AUTO_LOCK_TIME } from '@subwallet/extension-base/services/setting-service/constants';
 import { WALLET_CONNECT_EIP155_NAMESPACE } from '@subwallet/extension-base/services/wallet-connect-service/constants';
 import { isProposalExpired, isSupportWalletConnectChain, isSupportWalletConnectNamespace } from '@subwallet/extension-base/services/wallet-connect-service/helpers';
 import { SWStorage } from '@subwallet/extension-base/storage';
 import { AccountsStore } from '@subwallet/extension-base/stores';
-import { YieldPoolType } from '@subwallet/extension-base/types';
-import { BN_ZERO, convertSubjectInfoToAddresses, createPromiseHandler, createTransactionFromRLP, isSameAddress, MODULE_SUPPORT, reformatAddress, signatureToHex, uniqueStringArray } from '@subwallet/extension-base/utils';
+import { BasicTxErrorType, BasicTxWarningCode, StakingTxErrorType, YieldPoolType } from '@subwallet/extension-base/types';
+import { _analyzeAddress, BN_ZERO, combineAllAccountProxy, createTransactionFromRLP, isSameAddress, MODULE_SUPPORT, reformatAddress, signatureToHex, transformAccounts, transformAddresses, uniqueStringArray } from '@subwallet/extension-base/utils';
 import { parseContractInput, parseEvmRlp } from '@subwallet/extension-base/utils/eth/parseTransaction';
 import { metadataExpand } from '@subwallet/extension-chains';
-import { createPair } from '@subwallet/keyring';
+import { getKeypairTypeByAddress, isAddress, isSubstrateAddress, isTonAddress } from '@subwallet/keyring';
+import { EthereumKeypairTypes, SubstrateKeypairTypes, TonKeypairTypes } from '@subwallet/keyring/types';
 import { keyring } from '@subwallet/ui-keyring';
 import { getSdkError } from '@walletconnect/utils';
 import BigN from 'bignumber.js';
 import { t } from 'i18next';
-import { Subject } from 'rxjs';
+import { combineLatest, Subject } from 'rxjs';
 import { Metadata, TypeRegistry } from '@polkadot/types';
-import { assert, hexStripPrefix, hexToU8a, isAscii, isHex, u8aToHex, u8aToString } from '@polkadot/util';
-import { base64Decode, decodeAddress, isAddress, isEthereumAddress, jsonDecrypt, keyExtractSuri, mnemonicGenerate, mnemonicValidate } from '@polkadot/util-crypto';
-const ETH_DERIVE_DEFAULT = '/m/44\'/60\'/0\'/0/0';
-function getSuri(seed, type) {
-  return type === 'ethereum' ? `${seed}${ETH_DERIVE_DEFAULT}` : seed;
-}
-function transformAccounts(accounts) {
-  return Object.values(accounts).map(({
-    json: {
-      address,
-      meta
-    },
-    type
-  }) => ({
-    address,
-    ...meta,
-    type
-  }));
-}
-const ACCOUNT_ALL_JSON = {
-  address: ALL_ACCOUNT_KEY,
-  name: 'All'
-};
-export const SEED_DEFAULT_LENGTH = 12;
-export const SEED_LENGTHS = [12, 15, 18, 21, 24];
+import { assert, hexStripPrefix, hexToU8a, isAscii, isHex, u8aToHex } from '@polkadot/util';
+import { decodeAddress, isEthereumAddress } from '@polkadot/util-crypto';
 export function isJsonPayload(value) {
   return value.genesisHash !== undefined;
 }
@@ -79,6 +59,11 @@ export default class KoniExtension {
   #skipAutoLock = false;
   #firstTime = true;
   #alwaysLock = false;
+  /**
+   * Use for heartbeat.
+   * When auto-lock runs, the value changes, and it stops the heartbeat.
+   * With MV3, when the lifecycle ends, this extension Object will be destroyed, so #keyringLockSubject will be destroyed too.
+   * */
   #keyringLockSubject = new Subject();
   constructor(state) {
     this.#koniState = state;
@@ -117,76 +102,14 @@ export default class KoniExtension {
       next: updateTimeAutoLock
     });
   }
-
-  /// Clone from PolkadotJs
-  accountsCreateExternal({
-    address,
-    genesisHash,
-    name
-  }) {
-    keyring.addExternal(address, {
-      genesisHash,
-      name
-    });
-    return true;
-  }
-  accountsCreateHardware({
-    accountIndex,
-    address,
-    addressOffset,
-    genesisHash,
-    hardwareType,
-    name
-  }) {
-    keyring.addHardware(address, hardwareType, {
-      accountIndex,
-      addressOffset,
-      genesisHash,
-      name
-    });
-    return true;
+  accountsEdit(request) {
+    return this.#koniState.keyringService.context.accountsEdit(request);
   }
-  accountsCreateSuri({
-    genesisHash,
-    name,
-    suri,
-    type
-  }) {
-    keyring.addUri(getSuri(suri, type), {
-      genesisHash,
-      name
-    }, type);
-    return true;
+  tonGetAllTonWalletContractVersion(request) {
+    return this.#koniState.keyringService.context.tonGetAllTonWalletContractVersion(request);
   }
-  accountsChangePassword({
-    address,
-    newPass,
-    oldPass
-  }) {
-    const pair = keyring.getPair(address);
-    assert(pair, t('Unable to find account'));
-    try {
-      if (!pair.isLocked) {
-        pair.lock();
-      }
-      pair.decodePkcs8(oldPass);
-    } catch (error) {
-      throw new Error(t('Wrong password'));
-    }
-    keyring.encryptAccount(pair, newPass);
-    return true;
-  }
-  accountsEdit({
-    address,
-    name
-  }) {
-    const pair = keyring.getPair(address);
-    assert(pair, t('Unable to find account'));
-    keyring.saveAccountMeta(pair, {
-      ...pair.meta,
-      name
-    });
-    return true;
+  tonAccountChangeWalletContractVersion(request) {
+    return this.#koniState.keyringService.context.tonAccountChangeWalletContractVersion(request);
   }
   accountsExport({
     address,
@@ -196,41 +119,6 @@ export default class KoniExtension {
       exportedJson: keyring.backupAccount(keyring.getPair(address), password)
     };
   }
-  accountsShow({
-    address,
-    isShowing
-  }) {
-    const pair = keyring.getPair(address);
-    assert(pair, t('Unable to find account'));
-    keyring.saveAccountMeta(pair, {
-      ...pair.meta,
-      isHidden: !isShowing
-    });
-    return true;
-  }
-  accountsValidate({
-    address,
-    password
-  }) {
-    try {
-      keyring.backupAccount(keyring.getPair(address), password);
-      return true;
-    } catch (e) {
-      return false;
-    }
-  }
-
-  // FIXME This looks very much like what we have in Tabs
-  accountsSubscribe(id, port) {
-    const cb = createSubscription(id, port);
-    const accountSubject = this.#koniState.keyringService.accountSubject;
-    const subscription = accountSubject.subscribe(accounts => cb(transformAccounts(accounts)));
-    port.onDisconnect.addListener(() => {
-      this.cancelSubscription(id);
-      subscription.unsubscribe();
-    });
-    return true;
-  }
   metadataApprove({
     id
   }) {
@@ -270,81 +158,6 @@ export default class KoniExtension {
     });
     return this.#koniState.metaSubject.value;
   }
-  jsonRestore({
-    file,
-    password
-  }) {
-    try {
-      keyring.restoreAccount(file, password, true);
-    } catch (error) {
-      throw new Error(error.message);
-    }
-  }
-  batchRestore({
-    file,
-    password
-  }) {
-    try {
-      keyring.restoreAccounts(file, password);
-    } catch (error) {
-      throw new Error(error.message);
-    }
-  }
-  jsonGetAccountInfo(json) {
-    try {
-      const {
-        address,
-        meta: {
-          genesisHash,
-          name
-        },
-        type
-      } = keyring.createFromJson(json);
-      return {
-        address,
-        genesisHash,
-        name,
-        type
-      };
-    } catch (e) {
-      console.error(e);
-      throw new Error(e.message);
-    }
-  }
-  seedCreate({
-    length = SEED_DEFAULT_LENGTH,
-    seed: _seed,
-    type
-  }) {
-    const seed = _seed || mnemonicGenerate(length);
-    return {
-      address: keyring.createFromUri(getSuri(seed, type), {}, type).address,
-      seed
-    };
-  }
-  seedValidate({
-    suri,
-    type
-  }) {
-    const {
-      phrase
-    } = keyExtractSuri(suri);
-    if (isHex(phrase)) {
-      assert(isHex(phrase, 256), t('Invalid seed phrase. Please try again.'));
-    } else {
-      // sadly isHex detects as string, so we need a cast here
-      assert(SEED_LENGTHS.includes(phrase.split(' ').length), t('Seed phrase needs to contain {{x}} words', {
-        replace: {
-          x: SEED_LENGTHS.join(', ')
-        }
-      }));
-      assert(mnemonicValidate(phrase), t('Invalid seed phrase. Please try again.'));
-    }
-    return {
-      address: keyring.createFromUri(getSuri(suri, type), {}, type).address,
-      suri
-    };
-  }
 
   // TODO: move to request service
   signingApproveSignature({
@@ -414,50 +227,6 @@ export default class KoniExtension {
     }));
     return true;
   }
-  derive(parentAddress, suri, password, metadata) {
-    const parentPair = keyring.getPair(parentAddress);
-    try {
-      parentPair.decodePkcs8(password);
-    } catch (e) {
-      throw new Error(t('Wrong password'));
-    }
-    try {
-      return parentPair.derive(suri, metadata);
-    } catch (err) {
-      throw new Error(t('"{{suri}}" is not a valid derivation path', {
-        replace: {
-          suri
-        }
-      }));
-    }
-  }
-  derivationValidate({
-    parentAddress,
-    parentPassword,
-    suri
-  }) {
-    const childPair = this.derive(parentAddress, suri, parentPassword, {});
-    return {
-      address: childPair.address,
-      suri
-    };
-  }
-  derivationCreate({
-    genesisHash,
-    name,
-    parentAddress,
-    parentPassword,
-    suri
-  }) {
-    const childPair = this.derive(parentAddress, suri, parentPassword, {
-      genesisHash,
-      name,
-      parentAddress,
-      suri
-    });
-    keyring.addPair(childPair, true);
-    return true;
-  }
 
   ///
 
@@ -467,78 +236,101 @@ export default class KoniExtension {
   createUnsubscriptionHandle(id, unsubscribe) {
     this.#koniState.createUnsubscriptionHandle(id, unsubscribe);
   }
-  decodeAddress = (key, ignoreChecksum, ss58Format) => {
-    return keyring.decodeAddress(key, ignoreChecksum, ss58Format);
-  };
-  encodeAddress = (key, ss58Format) => {
-    return keyring.encodeAddress(key, ss58Format);
-  };
-  accountExportPrivateKey({
-    address,
-    password
-  }) {
-    return this.#koniState.accountExportPrivateKey({
-      address,
-      password
-    });
+  accountExportPrivateKey(request) {
+    return this.#koniState.accountExportPrivateKey(request);
   }
   checkPublicAndSecretKey(request) {
     return this.#koniState.checkPublicAndSecretKey(request);
   }
+  checkNameExists(request) {
+    return this.#koniState.keyringService.context.checkNameExists(request);
+  }
   async accountsGetAllWithCurrentAddress(id, port) {
     const cb = createSubscription(id, port);
     const keyringService = this.#koniState.keyringService;
     await this.#koniState.eventService.waitAccountReady;
     await this.#koniState.eventService.waitInjectReady;
-    const currentAccount = keyringService.currentAccount;
-    const transformedAccounts = transformAccounts(keyringService.accounts);
+    const currentAccount = keyringService.context.currentAccount;
+    const accounts = keyringService.context.accounts;
+    const transformedAccounts = Object.values(accounts);
     const responseData = {
-      accounts: transformedAccounts !== null && transformedAccounts !== void 0 && transformedAccounts.length ? [{
-        ...ACCOUNT_ALL_JSON
-      }, ...transformedAccounts] : [],
-      currentAddress: currentAccount === null || currentAccount === void 0 ? void 0 : currentAccount.address,
-      currentGenesisHash: currentAccount === null || currentAccount === void 0 ? void 0 : currentAccount.currentGenesisHash
+      accounts: transformedAccounts !== null && transformedAccounts !== void 0 && transformedAccounts.length ? [combineAllAccountProxy(transformedAccounts), ...transformedAccounts] : [],
+      currentAccountProxy: currentAccount === null || currentAccount === void 0 ? void 0 : currentAccount.proxyId
     };
-    const subscriptionAccounts = keyringService.accountSubject.subscribe(storedAccounts => {
-      const transformedAccounts = transformAccounts(storedAccounts);
-      responseData.accounts = transformedAccounts !== null && transformedAccounts !== void 0 && transformedAccounts.length ? [{
-        ...ACCOUNT_ALL_JSON
-      }, ...transformedAccounts] : [];
-      cb(responseData);
-    });
-    const subscriptionCurrentAccount = keyringService.currentAccountSubject.subscribe(currentAccountData => {
-      responseData.currentAddress = currentAccountData.address;
-      responseData.currentGenesisHash = currentAccountData.currentGenesisHash;
+    const accountProxyMapObservable = keyringService.context.observable.accounts;
+    const currentAccountInfoObservable = keyringService.context.observable.currentAccount;
+    const subscriptionAccountGroups = combineLatest({
+      accountProxies: accountProxyMapObservable,
+      currentAccount: currentAccountInfoObservable
+    }).subscribe(({
+      accountProxies,
+      currentAccount
+    }) => {
+      const transformedAccounts = Object.values(accountProxies);
+      responseData.accounts = transformedAccounts !== null && transformedAccounts !== void 0 && transformedAccounts.length ? [combineAllAccountProxy(transformedAccounts), ...transformedAccounts] : [];
+      responseData.currentAccountProxy = currentAccount === null || currentAccount === void 0 ? void 0 : currentAccount.proxyId;
+      console.debug('subscriptionAccountGroups', responseData);
       cb(responseData);
     });
     this.createUnsubscriptionHandle(id, () => {
-      subscriptionAccounts.unsubscribe();
-      subscriptionCurrentAccount.unsubscribe();
+      subscriptionAccountGroups.unsubscribe();
     });
     port.onDisconnect.addListener(() => {
       this.cancelSubscription(id);
     });
     return responseData;
   }
-  accountsGetAll(id, port) {
+  async subscribeInputAddressData(request, id, port) {
+    const {
+      chain,
+      data
+    } = request;
     const cb = createSubscription(id, port);
-    const subscription = keyring.keyringOption.optionsSubject.subscribe(options => {
-      const optionsInputAddress = {
-        options
+    const combineFunction = async (chainInfoMap, accountProxyMap, _contacts) => {
+      const accountProxies = Object.values(accountProxyMap);
+      const contacts = transformAddresses(_contacts);
+      const chainInfo = chainInfoMap[chain];
+      const substrateApi = this.#koniState.chainService.getSubstrateApi(chain);
+      const rs = await _analyzeAddress(data, accountProxies, contacts, chainInfo, substrateApi);
+      return {
+        id,
+        ...rs
       };
-      cb(optionsInputAddress);
+    };
+    const accountObservable = this.#koniState.keyringService.context.observable.accounts;
+    const contactObservable = this.#koniState.keyringService.context.observable.contacts;
+    const chainInfoMapObservable = this.#koniState.chainService.subscribeChainInfoMap().asObservable();
+    const subscription = combineLatest({
+      chainInfoMap: chainInfoMapObservable,
+      accountProxies: accountObservable,
+      contacts: contactObservable
+    }).subscribe(({
+      accountProxies,
+      chainInfoMap,
+      contacts
+    }) => {
+      combineFunction(chainInfoMap, accountProxies, contacts).then(rs => cb(rs)).catch(console.error);
+    });
+    this.createUnsubscriptionHandle(id, () => {
+      subscription.unsubscribe();
     });
-    this.createUnsubscriptionHandle(id, subscription.unsubscribe);
     port.onDisconnect.addListener(() => {
       this.cancelSubscription(id);
     });
-    return id;
+    const accountProxyMap = this.#koniState.keyringService.context.value.accounts;
+    const contacts = this.#koniState.keyringService.context.value.contacts;
+    const chainInfoMap = this.#koniState.chainService.getChainInfoMap();
+    return combineFunction(chainInfoMap, accountProxyMap, contacts);
   }
+
+  /**
+   * @todo: move to keyring context
+   * */
   subscribeAddresses(id, port) {
     const _cb = createSubscription(id, port);
     let old = '';
-    const subscription = this.#koniState.keyringService.addressesSubject.subscribe(subjectInfo => {
-      const addresses = convertSubjectInfoToAddresses(subjectInfo);
+    const subscription = this.#koniState.keyringService.context.observable.contacts.subscribe(subjectInfo => {
+      const addresses = transformAddresses(subjectInfo);
       const _new = JSON.stringify(addresses);
       if (old !== _new) {
         _cb({
@@ -547,15 +339,21 @@ export default class KoniExtension {
         old = _new;
       }
     });
-    this.createUnsubscriptionHandle(id, subscription.unsubscribe);
+    this.createUnsubscriptionHandle(id, () => {
+      subscription.unsubscribe();
+    });
     port.onDisconnect.addListener(() => {
       this.cancelSubscription(id);
     });
-    const subjectInfo = this.#koniState.keyringService.addresses;
+    const subjectInfo = this.#koniState.keyringService.context.contacts;
     return {
-      addresses: convertSubjectInfoToAddresses(subjectInfo)
+      addresses: transformAccounts(subjectInfo)
     };
   }
+
+  /**
+   * @todo: move to keyring context
+   * */
   saveRecentAccount({
     accountId,
     chain
@@ -584,7 +382,7 @@ export default class KoniExtension {
           }
         }
         metadata.recentChainSlugs = recentChainSlugs;
-        const result = keyring.addresses.add(new AccountsStore(), address, {
+        const result = keyring.addresses.add(new AccountsStore(), address, address, {
           address: address,
           meta: metadata
         });
@@ -597,6 +395,10 @@ export default class KoniExtension {
       throw Error(t('This is not an address'));
     }
   }
+
+  /**
+   * @todo: move to keyring context
+   * */
   editContactAccount({
     address,
     meta
@@ -609,6 +411,10 @@ export default class KoniExtension {
       throw Error(t('This is not an address'));
     }
   }
+
+  /**
+   * @todo: move to keyring context
+   * */
   deleteContactAccount({
     address
   }) {
@@ -624,7 +430,7 @@ export default class KoniExtension {
     const keyringService = this.#koniState.keyringService;
     return new Promise((resolve, reject) => {
       this.#koniState.getAuthorize(rs => {
-        const addressList = Object.keys(keyringService.accounts);
+        const addressList = Object.keys(keyringService.context.pairs);
         const urlList = Object.keys(rs);
         if (Object.keys(rs[urlList[0]].isAllowedMap).toString() !== addressList.toString()) {
           urlList.forEach(url => {
@@ -737,37 +543,52 @@ export default class KoniExtension {
     });
     return true;
   }
-  getAccounts() {
-    const storedAccounts = this.#koniState.keyringService.accounts;
-    const transformedAccounts = transformAccounts(storedAccounts);
-    return transformedAccounts.map(a => a.address);
+  getPairs() {
+    const storedAccounts = this.#koniState.keyringService.context.pairs;
+    return transformAccounts(storedAccounts);
   }
-  isAddressValidWithAuthType(address, accountAuthType) {
-    if (accountAuthType === 'substrate') {
-      return !isEthereumAddress(address);
-    } else if (accountAuthType === 'evm') {
-      return isEthereumAddress(address);
-    }
-    return true;
+  isAddressValidWithAuthType(address, accountAuthTypes) {
+    const type = getKeypairTypeByAddress(address);
+    const validTypes = {
+      evm: EthereumKeypairTypes,
+      substrate: SubstrateKeypairTypes,
+      ton: TonKeypairTypes
+    };
+    return !!accountAuthTypes && accountAuthTypes.some(authType => {
+      var _validTypes$authType;
+      return (_validTypes$authType = validTypes[authType]) === null || _validTypes$authType === void 0 ? void 0 : _validTypes$authType.includes(type);
+    });
   }
-  filterAccountsByAccountAuthType(accounts, accountAuthType) {
-    if (accountAuthType === 'substrate') {
-      return accounts.filter(address => !isEthereumAddress(address));
-    } else if (accountAuthType === 'evm') {
-      return accounts.filter(address => isEthereumAddress(address));
-    } else {
-      return accounts;
+  filterAccountsByAccountAuthType(accounts, accountAuthTypes) {
+    if (!accountAuthTypes) {
+      return [];
     }
+    return accountAuthTypes.reduce((list, accountAuthType) => {
+      if (accountAuthType === 'evm') {
+        accounts.forEach(({
+          address
+        }) => isEthereumAddress(address) && list.push(address));
+      } else if (accountAuthType === 'substrate') {
+        accounts.forEach(({
+          address
+        }) => isSubstrateAddress(address) && list.push(address));
+      } else if (accountAuthType === 'ton') {
+        accounts.forEach(({
+          address
+        }) => isTonAddress(address) && list.push(address));
+      }
+      return list;
+    }, []);
   }
   _changeAuthorizationAll(connectValue, callBack) {
     this.#koniState.getAuthorize(value => {
       assert(value, 'The source is not known');
-      const accounts = this.getAccounts();
+      const pairs = this.getPairs();
       Object.keys(value).forEach(url => {
         if (!value[url].isAllowed) {
           return;
         }
-        const targetAccounts = this.filterAccountsByAccountAuthType(accounts, value[url].accountAuthType);
+        const targetAccounts = this.filterAccountsByAccountAuthType(pairs, value[url].accountAuthTypes);
         targetAccounts.forEach(address => {
           value[url].isAllowedMap[address] = connectValue;
         });
@@ -790,8 +611,8 @@ export default class KoniExtension {
   _changeAuthorization(url, connectValue, callBack) {
     this.#koniState.getAuthorize(value => {
       assert(value[url], 'The source is not known');
-      const accounts = this.getAccounts();
-      const targetAccounts = this.filterAccountsByAccountAuthType(accounts, value[url].accountAuthType);
+      const pairs = this.getPairs();
+      const targetAccounts = this.filterAccountsByAccountAuthType(pairs, value[url].accountAuthTypes);
       targetAccounts.forEach(address => {
         value[url].isAllowedMap[address] = connectValue;
       });
@@ -826,7 +647,7 @@ export default class KoniExtension {
   _changeAuthorizationPerAcc(address, connectValue, url, callBack) {
     this.#koniState.getAuthorize(value => {
       assert(value, 'The source is not known');
-      if (this.isAddressValidWithAuthType(address, value[url].accountAuthType)) {
+      if (this.isAddressValidWithAuthType(address, value[url].accountAuthTypes)) {
         value[url].isAllowedMap[address] = connectValue;
         this.#koniState.setAuthorize(value, () => {
           callBack && callBack(value);
@@ -981,39 +802,10 @@ export default class KoniExtension {
     });
     return await this.#koniState.getAuthList();
   }
-  _saveCurrentAccountAddress(address, callback) {
-    let accountInfo = this.#koniState.keyringService.currentAccount;
-    if (!accountInfo) {
-      accountInfo = {
-        address,
-        currentGenesisHash: ALL_GENESIS_HASH,
-        allGenesisHash: ALL_GENESIS_HASH || undefined
-      };
-    } else {
-      accountInfo.address = address;
-      if (address !== ALL_ACCOUNT_KEY) {
-        try {
-          const currentKeyPair = keyring.getPair(address);
-          accountInfo.currentGenesisHash = (currentKeyPair === null || currentKeyPair === void 0 ? void 0 : currentKeyPair.meta.genesisHash) || ALL_GENESIS_HASH;
-        } catch {
-          accountInfo.currentGenesisHash = ALL_GENESIS_HASH;
-        }
-      } else {
-        accountInfo.currentGenesisHash = accountInfo.allGenesisHash || ALL_GENESIS_HASH;
-      }
-    }
-    this.#koniState.setCurrentAccount(accountInfo, () => {
-      callback && callback(accountInfo);
-    });
-  }
-  updateCurrentAccountAddress(address) {
-    this._saveCurrentAccountAddress(address);
-    return true;
-  }
-  async saveCurrentAccountAddress(data) {
+  async saveCurrentAccountProxy(data) {
     return new Promise(resolve => {
-      this._saveCurrentAccountAddress(data.address, currentInfo => {
-        resolve(currentInfo);
+      this.#koniState.keyringService.context.saveCurrentAccountProxyId(data.address, () => {
+        resolve(true);
       });
     });
   }
@@ -1096,136 +888,24 @@ export default class KoniExtension {
     });
     return this.getCrowdloan(true);
   }
-  validatePassword(json, password) {
-    const cryptoType = Array.isArray(json.encoding.content) ? json.encoding.content[1] : 'ed25519';
-    const encType = Array.isArray(json.encoding.type) ? json.encoding.type : [json.encoding.type];
-    const pair = createPair({
-      toSS58: this.encodeAddress,
-      type: cryptoType
-    }, {
-      publicKey: this.decodeAddress(json.address, true)
-    }, json.meta, isHex(json.encoded) ? hexToU8a(json.encoded) : base64Decode(json.encoded), encType);
-
-    // unlock then lock (locking cleans secretKey, so needs to be last)
-    try {
-      pair.decodePkcs8(password);
-      pair.lock();
-      return true;
-    } catch (e) {
-      console.error(e);
-      return false;
-    }
-  }
-  validatedAccountsPassword(json, password) {
-    try {
-      u8aToString(jsonDecrypt(json, password));
-      return true;
-    } catch (e) {
-      return false;
-    }
-  }
-  _addAddressToAuthList(address, isAllowed) {
-    this.#koniState.getAuthorize(value => {
-      if (value && Object.keys(value).length) {
-        Object.keys(value).forEach(url => {
-          if (this.isAddressValidWithAuthType(address, value[url].accountAuthType)) {
-            value[url].isAllowedMap[address] = isAllowed;
-          }
-        });
-        this.#koniState.setAuthorize(value);
-      }
-    });
-  }
-  _addAddressesToAuthList(addresses, isAllowed) {
-    this.#koniState.getAuthorize(value => {
-      if (value && Object.keys(value).length) {
-        Object.keys(value).forEach(url => {
-          addresses.forEach(address => {
-            if (this.isAddressValidWithAuthType(address, value[url].accountAuthType)) {
-              value[url].isAllowedMap[address] = isAllowed;
-            }
-          });
-        }); /**/
-
-        this.#koniState.setAuthorize(value);
-      }
-    });
-  }
-  async accountsCreateSuriV2({
-    genesisHash,
-    isAllowed,
-    name,
-    password,
-    suri: _suri,
-    types
-  }) {
-    const addressDict = {};
-    let changedAccount = false;
-    const hasMasterPassword = keyring.keyring.hasMasterPassword;
-    if (!hasMasterPassword) {
-      if (!password) {
-        throw Error(t('The password of each account is needed to set up master password'));
-      } else {
-        keyring.changeMasterPassword(password);
-        this.#koniState.updateKeyringState();
-      }
-    }
-    const currentAccount = this.#koniState.keyringService.currentAccount;
-    const allGenesisHash = (currentAccount === null || currentAccount === void 0 ? void 0 : currentAccount.allGenesisHash) || undefined;
-    types === null || types === void 0 ? void 0 : types.forEach(type => {
-      const suri = getSuri(_suri, type);
-      const address = keyring.createFromUri(suri, {}, type).address;
-      addressDict[type] = address;
-      const newAccountName = type === 'ethereum' ? `${name} - EVM` : name;
-      keyring.addUri(suri, {
-        genesisHash,
-        name: newAccountName
-      }, type);
-      this._addAddressToAuthList(address, isAllowed);
-      if (!changedAccount) {
-        if (types.length === 1) {
-          this.#koniState.setCurrentAccount({
-            address,
-            currentGenesisHash: genesisHash || null,
-            allGenesisHash
-          });
-        } else {
-          this.#koniState.setCurrentAccount({
-            address: ALL_ACCOUNT_KEY,
-            currentGenesisHash: allGenesisHash || null,
-            allGenesisHash
-          }, undefined, true);
-        }
-        changedAccount = true;
-      }
-    });
-    await new Promise(resolve => {
-      this.#koniState.addAccountRef(Object.values(addressDict), () => {
-        resolve();
-      });
-    });
+  accountsCreateSuriV2(request) {
+    const addressDict = this.#koniState.keyringService.context.accountsCreateSuriV2(request);
     if (this.#alwaysLock) {
       this.keyringLock();
     }
     return addressDict;
   }
-  async accountsForgetOverride({
-    address,
-    lockAfter
-  }) {
-    keyring.forgetAccount(address);
-    await new Promise(resolve => {
-      this.#koniState.removeAccountRef(address, () => {
-        resolve();
-      });
-    });
+  async accountsForgetOverride(request) {
+    const addresses = await this.#koniState.keyringService.context.accountProxyForget(request);
 
     // Remove from auth list
     await new Promise(resolve => {
       this.#koniState.getAuthorize(value => {
         if (value && Object.keys(value).length) {
           Object.keys(value).forEach(url => {
-            delete value[url].isAllowedMap[address];
+            for (const address of addresses) {
+              delete value[url].isAllowedMap[address];
+            }
           });
           this.#koniState.setAuthorize(value, resolve);
         } else {
@@ -1233,242 +913,50 @@ export default class KoniExtension {
         }
       });
     });
-
-    // Set current account to all account
-    await new Promise(resolve => {
-      const currentAccountInfo = this.#koniState.keyringService.currentAccount;
-      this.#koniState.setCurrentAccount({
-        currentGenesisHash: (currentAccountInfo === null || currentAccountInfo === void 0 ? void 0 : currentAccountInfo.allGenesisHash) || null,
-        address: ALL_ACCOUNT_KEY
-      }, resolve);
-    });
-    await this.#koniState.disableMantaPay(address);
-    if (lockAfter) {
+    for (const address of addresses) {
+      await this.#koniState.disableMantaPay(address);
+    }
+    if (request.lockAfter) {
       this.checkLockAfterMigrate();
     }
     return true;
   }
-  seedCreateV2({
-    length = SEED_DEFAULT_LENGTH,
-    seed: _seed,
-    types
-  }) {
-    const seed = _seed || mnemonicGenerate(length);
-    const rs = {
-      seed: seed,
-      addressMap: {}
-    };
-    types === null || types === void 0 ? void 0 : types.forEach(type => {
-      rs.addressMap[type] = keyring.createFromUri(getSuri(seed, type), {}, type).address;
-    });
-    return rs;
+  seedCreateV2(request) {
+    return this.#koniState.keyringService.context.mnemonicCreateV2(request);
   }
-  seedValidateV2({
-    suri,
-    types
-  }) {
-    const {
-      phrase
-    } = keyExtractSuri(suri);
-    if (isHex(phrase)) {
-      assert(isHex(phrase, 256), t('Invalid seed phrase. Please try again.'));
-    } else {
-      // sadly isHex detects as string, so we need a cast here
-      assert(SEED_LENGTHS.includes(phrase.split(' ').length), t('Seed phrase needs to contain {{x}} words', {
-        replace: {
-          x: SEED_LENGTHS.join(', ')
-        }
-      }));
-      assert(mnemonicValidate(phrase), t('Invalid seed phrase. Please try again.'));
-    }
-    const rs = {
-      seed: suri,
-      addressMap: {}
-    };
-    types && types.forEach(type => {
-      rs.addressMap[type] = keyring.createFromUri(getSuri(suri, type), {}, type).address;
-    });
-    return rs;
+  seedValidateV2(request) {
+    return this.#koniState.keyringService.context.mnemonicValidateV2(request);
   }
-  _checkValidatePrivateKey({
-    suri,
-    types
-  }, autoAddPrefix = false) {
-    const {
-      phrase
-    } = keyExtractSuri(suri);
-    const rs = {
-      autoAddPrefix: autoAddPrefix,
-      addressMap: {}
-    };
-    types && types.forEach(type => {
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-      rs.addressMap[type] = '';
-    });
-    if (isHex(phrase) && isHex(phrase, 256)) {
-      types && types.forEach(type => {
-        rs.addressMap[type] = keyring.createFromUri(getSuri(suri, type), {}, type).address;
-      });
-    } else {
-      rs.autoAddPrefix = false;
-      assert(false, t('Invalid private key. Please try again.'));
-    }
-    return rs;
-  }
-  metamaskPrivateKeyValidateV2({
-    suri,
-    types
-  }) {
-    const isValidSuri = suri.startsWith('0x');
-    if (isValidSuri) {
-      return this._checkValidatePrivateKey({
-        suri,
-        types
-      });
-    } else {
-      return this._checkValidatePrivateKey({
-        suri: `0x${suri}`,
-        types
-      }, true);
-    }
+  privateKeyValidateV2(request) {
+    return this.#koniState.keyringService.context.privateKeyValidateV2(request);
   }
-  deriveV2(parentAddress, suri, metadata) {
-    const parentPair = keyring.getPair(parentAddress);
-    if (parentPair.isLocked) {
-      keyring.unlockPair(parentPair.address);
-    }
-    try {
-      return parentPair.derive(suri, metadata);
-    } catch (err) {
-      throw new Error(t('"{{suri}}" is not a valid derivation path', {
-        replace: {
-          suri
-        }
-      }));
-    }
+
+  /* JSON */
+
+  parseInfoSingleJson(request) {
+    return this.#koniState.keyringService.context.parseInfoSingleJson(request);
   }
-  derivationCreateV2({
-    genesisHash,
-    isAllowed,
-    name,
-    parentAddress,
-    suri
-  }) {
-    const childPair = this.deriveV2(parentAddress, suri, {
-      genesisHash,
-      name,
-      parentAddress,
-      suri
-    });
-    const address = childPair.address;
-    this._saveCurrentAccountAddress(address, () => {
-      keyring.addPair(childPair, true);
-      this._addAddressToAuthList(address, isAllowed);
+  async jsonRestoreV2(request) {
+    return await this.#koniState.keyringService.context.jsonRestoreV2(request, () => {
+      if (this.#alwaysLock) {
+        this.keyringLock();
+      }
     });
-    return true;
   }
-  jsonRestoreV2({
-    address,
-    file,
-    isAllowed,
-    password,
-    withMasterPassword
-  }) {
-    const isPasswordValidated = this.validatePassword(file, password);
-    const {
-      promise,
-      resolve
-    } = createPromiseHandler();
-    if (isPasswordValidated) {
-      try {
-        this._saveCurrentAccountAddress(address, () => {
-          var _newAccount$meta, _newAccount$meta2;
-          const newAccount = keyring.restoreAccount(file, password, withMasterPassword);
-
-          // genesisHash is not used in SubWallet => reset it to empty string
-          if ((_newAccount$meta = newAccount.meta) !== null && _newAccount$meta !== void 0 && _newAccount$meta.genesisHash && ((_newAccount$meta2 = newAccount.meta) === null || _newAccount$meta2 === void 0 ? void 0 : _newAccount$meta2.genesisHash) !== '') {
-            keyring.saveAccountMeta(newAccount, {
-              ...newAccount.meta,
-              genesisHash: ''
-            });
-          }
-          this._addAddressToAuthList(address, isAllowed);
-          resolve([address]);
-        });
-        if (this.#alwaysLock) {
-          this.keyringLock();
-        }
-        return promise;
-      } catch (error) {
-        throw new Error(error.message);
-      }
-    } else {
-      throw new Error(t('Wrong password'));
-    }
+  parseInfoMultiJson(request) {
+    return this.#koniState.keyringService.context.parseInfoMultiJson(request);
+  }
+  batchRestoreV2(request) {
+    return this.#koniState.keyringService.context.batchRestoreV2(request);
+  }
+  async batchExportV2(request) {
+    return this.#koniState.keyringService.context.batchExportV2(request);
   }
-  batchRestoreV2({
-    accountsInfo,
-    file,
-    isAllowed,
-    password
-  }) {
-    const addressList = accountsInfo.map(acc => acc.address);
-    const isPasswordValidated = this.validatedAccountsPassword(file, password);
-    const {
-      promise,
-      resolve
-    } = createPromiseHandler();
-    if (isPasswordValidated) {
-      try {
-        this._saveCurrentAccountAddress(ALL_ACCOUNT_KEY, () => {
-          keyring.restoreAccounts(file, password);
-          this.#koniState.keyringService.removeNoneHardwareGenesisHash();
-          const successAddressList = addressList.reduce((addressList, address) => {
-            try {
-              const account = keyring.getPair(address);
-              if (account) {
-                addressList.push(address);
-              }
-            } catch (error) {
-              console.log(error);
-            }
-            return addressList;
-          }, []);
-          this._addAddressesToAuthList(successAddressList, isAllowed);
-          resolve(successAddressList);
-        });
 
-        // if (this.#alwaysLock) {
-        //   this.keyringLock();
-        // }
+  /* JSON */
 
-        return promise;
-      } catch (error) {
-        throw new Error(error.message);
-      }
-    } else {
-      throw new Error(t('Wrong password'));
-    }
-  }
-  async batchExportV2({
-    addresses,
-    password
-  }) {
-    try {
-      if (addresses && !addresses.length) {
-        throw new Error(t('No accounts found to export'));
-      }
-      return {
-        exportedJson: await keyring.backupAccounts(password, addresses)
-      };
-    } catch (e) {
-      const error = e;
-      if (error.message === 'Invalid master password') {
-        throw new Error(t('Wrong password'));
-      } else {
-        throw error;
-      }
-    }
+  exportAccountProxyMnemonic(request) {
+    return this.#koniState.keyringService.context.exportAccountProxyMnemonic(request);
   }
   getNftCollection() {
     return this.#koniState.getNftCollection();
@@ -1610,12 +1098,12 @@ export default class KoniExtension {
       to,
       tokenSlug,
       transferAll,
+      transferBounceable,
       value
     } = inputData;
     const transferTokenInfo = this.#koniState.chainService.getAssetBySlug(tokenSlug);
     const [errors,,] = validateTransferRequest(transferTokenInfo, from, to, value, transferAll);
     const warnings = [];
-    const evmApiMap = this.#koniState.getEvmApiMap();
     const chainInfo = this.#koniState.getChainInfo(networkKey);
     const nativeTokenInfo = this.#koniState.getNativeTokenInfo(networkKey);
     const nativeTokenSlug = nativeTokenInfo.slug;
@@ -1638,8 +1126,9 @@ export default class KoniExtension {
       if (isEthereumAddress(from) && isEthereumAddress(to) && _isTokenTransferredByEvm(transferTokenInfo)) {
         chainType = ChainType.EVM;
         const txVal = transferAll ? transferTokenAvailable.value : value || '0';
-        const evmApi = evmApiMap[networkKey];
+        const evmApi = this.#koniState.getEvmApi(networkKey);
 
+        // todo: refactor: merge getERC20TransactionObject & getEVMTransactionObject
         // Estimate with EVM API
         if (_isTokenEvmSmartContract(transferTokenInfo) || _isLocalToken(transferTokenInfo)) {
           [transaction, transferAmount.value] = await getERC20TransactionObject(_getContractAddressOfToken(transferTokenInfo), chainInfo, from, to, txVal, !!transferAll, evmApi);
@@ -1649,6 +1138,19 @@ export default class KoniExtension {
       } else if (_isMantaZkAsset(transferTokenInfo)) {
         transaction = undefined;
         transferAmount.value = '0';
+      } else if (isTonAddress(from) && isTonAddress(to) && _isTokenTransferredByTon(transferTokenInfo)) {
+        chainType = ChainType.TON;
+        const tonApi = this.#koniState.getTonApi(networkKey);
+        [transaction, transferAmount.value] = await createTonTransaction({
+          tokenInfo: transferTokenInfo,
+          from,
+          to,
+          networkKey,
+          value: value || '0',
+          transferAll: !!transferAll,
+          // currently not used
+          tonApi
+        });
       } else {
         const substrateApi = this.#koniState.getSubstrateApi(networkKey);
         [transaction, transferAmount.value] = await createTransferExtrinsic({
@@ -1702,6 +1204,13 @@ export default class KoniExtension {
       warnings.length && inputTransaction.warnings.push(...warnings);
       errors.length && inputTransaction.errors.push(...errors);
     };
+    const ignoreWarnings = [];
+    if (transferAll) {
+      ignoreWarnings.push(BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT);
+    }
+    if (transferBounceable) {
+      ignoreWarnings.push(BasicTxWarningCode.IS_BOUNCEABLE_ADDRESS);
+    }
     return this.#koniState.transactionService.handleTransaction({
       errors,
       warnings,
@@ -1712,7 +1221,7 @@ export default class KoniExtension {
       transaction,
       data: inputData,
       extrinsicType,
-      ignoreWarnings: transferAll,
+      ignoreWarnings,
       isTransferAll: isTransferNativeToken ? transferAll : false,
       edAsWarning: isTransferNativeToken,
       additionalValidator: additionalValidator
@@ -1725,6 +1234,8 @@ export default class KoniExtension {
       originNetworkKey,
       to,
       tokenSlug,
+      transferAll,
+      transferBounceable,
       value
     } = inputData;
     const originTokenInfo = this.#koniState.getAssetBySlug(tokenSlug);
@@ -1802,6 +1313,13 @@ export default class KoniExtension {
         });
       };
     }
+    const ignoreWarnings = [];
+    if (transferAll) {
+      ignoreWarnings.push(BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT);
+    }
+    if (transferBounceable) {
+      ignoreWarnings.push(BasicTxWarningCode.IS_BOUNCEABLE_ADDRESS);
+    }
     return await this.#koniState.transactionService.handleTransaction({
       url: EXTENSION_REQUEST_URL,
       address: from,
@@ -1811,8 +1329,8 @@ export default class KoniExtension {
       extrinsicType: ExtrinsicType.TRANSFER_XCM,
       chainType: !isSnowBridgeEvmTransfer ? ChainType.SUBSTRATE : ChainType.EVM,
       transferNativeAmount: _isNativeToken(originTokenInfo) ? value : '0',
-      ignoreWarnings: inputData.transferAll,
-      isTransferAll: inputData.transferAll,
+      ignoreWarnings,
+      isTransferAll: transferAll,
       errors,
       additionalValidator: additionalValidator,
       eventsHandler: eventsHandler
@@ -1982,7 +1500,7 @@ export default class KoniExtension {
   }
   async getNativeTokenMaxTransferable(tokenInfo, networkKey, address) {
     const chainInfo = this.#koniState.chainService.getChainInfoByKey(networkKey);
-    const api = _isChainEvmCompatible(chainInfo) && _isTokenTransferredByEvm(tokenInfo) ? this.#koniState.chainService.getEvmApi(networkKey) : this.#koniState.chainService.getSubstrateApi(networkKey);
+    const api = _isChainEvmCompatible(chainInfo) && _isTokenTransferredByEvm(tokenInfo) ? this.#koniState.chainService.getEvmApi(networkKey) : _isChainTonCompatible(chainInfo) && _isTokenTransferredByTon(tokenInfo) ? this.#koniState.chainService.getTonApi(networkKey) : this.#koniState.chainService.getSubstrateApi(networkKey);
     const [mockTxFee, {
       value
     }] = await Promise.all([getTransferMockTxFee(address, chainInfo, tokenInfo, api), this.getAddressTransferableBalance({
@@ -2064,271 +1582,21 @@ export default class KoniExtension {
     }
     return true;
   }
-  getAccountMeta({
-    address
-  }) {
-    const pair = keyring.getPair(address);
-    assert(pair, t('Unable to find account'));
-    return {
-      meta: pair.meta
-    };
-  }
-  accountsTie2({
-    address,
-    genesisHash
-  }) {
-    return this.#koniState.setAccountTie(address, genesisHash);
+  async accountsCreateExternalV2(request) {
+    return this.#koniState.keyringService.context.accountsCreateExternalV2(request);
   }
-  async accountsCreateExternalV2({
-    address,
-    genesisHash,
-    isAllowed,
-    isEthereum,
-    isReadOnly,
-    name
-  }) {
-    try {
-      let result;
-      try {
-        const exists = keyring.getPair(address);
-        if (exists) {
-          if (exists.type === (isEthereum ? 'ethereum' : 'sr25519')) {
-            return [{
-              code: AccountExternalErrorCode.INVALID_ADDRESS,
-              message: t('Account exists')
-            }];
-          }
-        }
-      } catch (e) {}
-      if (isEthereum) {
-        const chainInfoMap = this.#koniState.getChainInfoMap();
-        let _gen = '';
-        if (genesisHash) {
-          for (const network of Object.values(chainInfoMap)) {
-            if (_getEvmChainId(network) === parseInt(genesisHash)) {
-              // TODO: pure EVM chains do not have genesisHash
-              _gen = _getSubstrateGenesisHash(network);
-            }
-          }
-        }
-        result = keyring.keyring.addFromAddress(address, {
-          name,
-          isExternal: true,
-          isReadOnly,
-          genesisHash: _gen
-        }, null, 'ethereum');
-        keyring.saveAccount(result);
-      } else {
-        result = keyring.addExternal(address, {
-          genesisHash,
-          name,
-          isReadOnly
-        }).pair;
-      }
-      const _address = result.address;
-      await new Promise(resolve => {
-        this.#koniState.addAccountRef([_address], () => {
-          resolve();
-        });
-      });
-      await new Promise(resolve => {
-        this._saveCurrentAccountAddress(_address, () => {
-          this._addAddressToAuthList(_address, isAllowed);
-          resolve();
-        });
-      });
-      return [];
-    } catch (e) {
-      return [{
-        code: AccountExternalErrorCode.KEYRING_ERROR,
-        message: e.message
-      }];
-    }
+  async accountsCreateHardwareV2(request) {
+    return this.#koniState.keyringService.context.accountsCreateHardwareV2(request);
   }
-  async accountsCreateHardwareV2({
-    accountIndex,
-    address,
-    addressOffset,
-    genesisHash,
-    hardwareType,
-    isAllowed,
-    name,
-    originGenesisHash
-  }) {
-    const key = keyring.addHardware(address, hardwareType, {
-      accountIndex,
-      addressOffset,
-      genesisHash,
-      name,
-      originGenesisHash
-    });
-    const result = key.pair;
-    const _address = result.address;
-    await new Promise(resolve => {
-      this.#koniState.addAccountRef([_address], () => {
-        resolve();
-      });
-    });
-    await new Promise(resolve => {
-      this._saveCurrentAccountAddress(_address, () => {
-        this._addAddressToAuthList(_address, isAllowed || false);
-        resolve();
-      });
-    });
-    return true;
+  async accountsCreateHardwareMultiple(request) {
+    return this.#koniState.keyringService.context.accountsCreateHardwareMultiple(request);
   }
-  async accountsCreateHardwareMultiple({
-    accounts
-  }) {
-    const addresses = [];
-    if (!accounts.length) {
-      throw new Error(t("Can't find an account. Please try again"));
-    }
-    const slugMap = {};
-    for (const account of accounts) {
-      const {
-        accountIndex,
-        address,
-        addressOffset,
-        genesisHash,
-        hardwareType,
-        isEthereum,
-        isGeneric,
-        name,
-        originGenesisHash
-      } = account;
-      let result;
-      const baseMeta = {
-        name,
-        hardwareType,
-        accountIndex,
-        addressOffset,
-        genesisHash,
-        originGenesisHash,
-        isGeneric
-      };
-      if (isEthereum) {
-        result = keyring.keyring.addFromAddress(address, {
-          ...baseMeta,
-          isExternal: true,
-          isHardware: true
-        }, null, 'ethereum');
-        keyring.saveAccount(result);
-        slugMap.ethereum = 'ethereum';
-      } else {
-        result = keyring.addHardware(address, hardwareType, {
-          ...baseMeta,
-          availableGenesisHashes: [genesisHash]
-        }).pair;
-        const [slug] = this.#koniState.findNetworkKeyByGenesisHash(genesisHash);
-        if (slug) {
-          slugMap[slug] = slug;
-        }
-      }
-      const _address = result.address;
-      addresses.push(_address);
-      await new Promise(resolve => {
-        this._addAddressToAuthList(_address, true);
-        resolve();
-      });
-    }
-    const currentAccount = this.#koniState.keyringService.currentAccount;
-    const allGenesisHash = (currentAccount === null || currentAccount === void 0 ? void 0 : currentAccount.allGenesisHash) || undefined;
-    if (addresses.length <= 1) {
-      this.#koniState.setCurrentAccount({
-        address: addresses[0],
-        currentGenesisHash: null,
-        allGenesisHash
-      });
-    } else {
-      this.#koniState.setCurrentAccount({
-        address: ALL_ACCOUNT_KEY,
-        currentGenesisHash: allGenesisHash || null,
-        allGenesisHash
-      });
-    }
-    await new Promise(resolve => {
-      this.#koniState.addAccountRef(addresses, () => {
-        resolve();
-      });
-    });
-    if (Object.keys(slugMap).length) {
-      this.enableChains({
-        chainSlugs: Object.keys(slugMap),
-        enableTokens: true
-      }).catch(console.error);
-    }
-    return true;
-  }
-  async accountsCreateWithSecret({
-    isAllow,
-    isEthereum,
-    name,
-    publicKey,
-    secretKey
-  }) {
-    try {
-      let keyringPair = null;
-      if (isEthereum) {
-        const _secret = hexStripPrefix(secretKey);
-        if (_secret.length === 64) {
-          const suri = `0x${_secret}`;
-          const {
-            phrase
-          } = keyExtractSuri(suri);
-          if (isHex(phrase) && isHex(phrase, 256)) {
-            const type = 'ethereum';
-            keyringPair = keyring.addUri(getSuri(suri, type), {
-              name: name
-            }, type).pair;
-          }
-        }
-      } else {
-        keyringPair = keyring.keyring.addFromPair({
-          publicKey: hexToU8a(publicKey),
-          secretKey: hexToU8a(secretKey)
-        }, {
-          name
-        });
-        keyring.addPair(keyringPair, true);
-      }
-      if (!keyringPair) {
-        return {
-          success: false,
-          errors: [{
-            code: AccountExternalErrorCode.KEYRING_ERROR,
-            message: t('Cannot create account')
-          }]
-        };
-      }
-      const _address = keyringPair.address;
-      await new Promise(resolve => {
-        this.#koniState.addAccountRef([_address], () => {
-          resolve();
-        });
-      });
-      await new Promise(resolve => {
-        this._saveCurrentAccountAddress(_address, () => {
-          this._addAddressToAuthList(_address, isAllow);
-          resolve();
-        });
-      });
-      if (this.#alwaysLock) {
-        this.keyringLock();
-      }
-      return {
-        errors: [],
-        success: true
-      };
-    } catch (e) {
-      return {
-        success: false,
-        errors: [{
-          code: AccountExternalErrorCode.KEYRING_ERROR,
-          message: e.message
-        }]
-      };
+  async accountsCreateWithSecret(request) {
+    const result = await this.#koniState.keyringService.context.accountsCreateWithSecret(request);
+    if (this.#alwaysLock) {
+      this.keyringLock();
     }
+    return result;
   }
 
   /// External account
@@ -2378,9 +1646,21 @@ export default class KoniExtension {
     });
     return this.#koniState.getConfirmationsQueueSubject().getValue();
   }
+  subscribeConfirmationsTon(id, port) {
+    const cb = createSubscription(id, port);
+    const subscription = this.#koniState.getConfirmationsQueueSubjectTon().subscribe(cb);
+    this.createUnsubscriptionHandle(id, subscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return this.#koniState.getConfirmationsQueueSubjectTon().getValue();
+  }
   async completeConfirmation(request) {
     return await this.#koniState.completeConfirmation(request);
   }
+  async completeConfirmationTon(request) {
+    return await this.#koniState.completeConfirmationTon(request);
+  }
 
   /// Sign Qr
 
@@ -2474,7 +1754,7 @@ export default class KoniExtension {
       } else if (isAscii(message)) {
         data = `0x${message}`;
       }
-      signed = await pair.evmSigner.signMessage(data, 'personal_sign');
+      signed = await pair.evm.signMessage(data, 'personal_sign');
     } else {
       var _signedTranaction$r, _signedTranaction$s, _signedTranaction$v;
       const tx = createTransactionFromRLP(message);
@@ -2501,7 +1781,7 @@ export default class KoniExtension {
       const transaction = new LegacyTransaction(txObject, {
         common
       });
-      const signedTranaction = LegacyTransaction.fromSerializedTx(hexToU8a(pair.evmSigner.signTransaction(transaction)));
+      const signedTranaction = LegacyTransaction.fromSerializedTx(hexToU8a(pair.evm.signTransaction(transaction)));
       signed = signatureToHex({
         r: ((_signedTranaction$r = signedTranaction.r) === null || _signedTranaction$r === void 0 ? void 0 : _signedTranaction$r.toString(16)) || '',
         s: ((_signedTranaction$s = signedTranaction.s) === null || _signedTranaction$s === void 0 ? void 0 : _signedTranaction$s.toString(16)) || '',
@@ -2795,8 +2075,7 @@ export default class KoniExtension {
 
   keyringStateSubscribe(id, port) {
     const cb = createSubscription(id, port);
-    const keyringStateSubject = this.#koniState.keyringService.keyringStateSubject;
-    const subscription = keyringStateSubject.subscribe(value => cb(value));
+    const subscription = this.#koniState.keyringService.keyringStateSubscribe(cb);
     this.createUnsubscriptionHandle(id, subscription.unsubscribe);
     port.onDisconnect.addListener(() => {
       this.cancelSubscription(id);
@@ -2806,47 +2085,14 @@ export default class KoniExtension {
 
   // Change master password
 
-  keyringChangeMasterPassword({
-    createNew,
-    newPassword,
-    oldPassword
-  }) {
-    try {
-      // Remove isMasterPassword meta if createNew
-      if (createNew && !keyring.keyring.hasMasterPassword) {
-        const pairs = keyring.getPairs();
-        for (const pair of pairs) {
-          if (pair.meta.isInjected) {
-            // Empty
-          } else {
-            const meta = {
-              ...pair.meta,
-              isMasterPassword: false
-            };
-            if (!meta.originGenesisHash) {
-              meta.genesisHash = '';
-            }
-            pair.setMeta(meta);
-            keyring.saveAccountMeta(pair, pair.meta);
-          }
-        }
+  keyringChangeMasterPassword(request) {
+    const createNew = request.createNew;
+    const callback = () => {
+      if (this.#alwaysLock && !createNew) {
+        this.keyringLock();
       }
-      keyring.changeMasterPassword(newPassword, oldPassword);
-    } catch (e) {
-      console.error(e);
-      return {
-        errors: [t(e.message)],
-        status: false
-      };
-    }
-    this.#koniState.updateKeyringState();
-    if (this.#alwaysLock && !createNew) {
-      this.keyringLock();
-    }
-    return {
-      status: true,
-      errors: []
     };
+    return this.#koniState.keyringService.context.keyringChangeMasterPassword(request, callback);
   }
 
   // Migrate password
@@ -2860,24 +2106,11 @@ export default class KoniExtension {
       }
     }
   }
-  keyringMigrateMasterPassword({
-    address,
-    password
-  }) {
-    try {
-      keyring.migrateWithMasterPassword(address, password);
+  keyringMigrateMasterPassword(request) {
+    const cb = () => {
       this.checkLockAfterMigrate();
-    } catch (e) {
-      console.error(e);
-      return {
-        errors: [e.message],
-        status: false
-      };
-    }
-    return {
-      status: true,
-      errors: []
     };
+    return this.#koniState.keyringService.context.keyringMigrateMasterPassword(request, cb);
   }
 
   // Unlock wallet
@@ -2956,7 +2189,7 @@ export default class KoniExtension {
       request,
       resolve
     } = queued;
-    const pair = keyring.getPair(queued.account.address);
+    const pair = keyring.getPair(queued.address);
 
     // unlike queued.account.address the following
     // address is encoded with the default prefix
@@ -3046,162 +2279,24 @@ export default class KoniExtension {
 
   /// Derive account
 
-  derivationCreateMultiple({
-    isAllowed,
-    items,
-    parentAddress
-  }) {
-    const parentPair = keyring.getPair(parentAddress);
-    const isEvm = parentPair.type === 'ethereum';
-    if (parentPair.isLocked) {
-      keyring.unlockPair(parentPair.address);
-    }
-    const createChild = ({
-      name,
-      suri
-    }) => {
-      const meta = {
-        name: name,
-        parentAddress
-      };
-      if (isEvm) {
-        let index = 0;
-        try {
-          const reg = /^\d+$/;
-          const path = suri.split('//')[1];
-          if (reg.test(path)) {
-            index = parseInt(path);
-          }
-        } catch (e) {}
-        if (!index) {
-          throw Error(t('Invalid derive path'));
-        }
-        meta.suri = `//${index}`;
-        return parentPair.deriveEvm(index, meta);
-      } else {
-        meta.suri = suri;
-        return parentPair.derive(suri, meta);
-      }
-    };
-    const result = [];
-    for (const item of items) {
-      try {
-        const childPair = createChild(item);
-        const address = childPair.address;
-        keyring.addPair(childPair, true);
-        this._addAddressToAuthList(address, isAllowed);
-        result.push(childPair);
-      } catch (e) {
-        console.log(e);
-      }
-    }
-    if (result.length === 1) {
-      this._saveCurrentAccountAddress(result[0].address);
-    } else {
-      this.#koniState.setCurrentAccount({
-        address: ALL_ACCOUNT_KEY,
-        currentGenesisHash: null
-      });
-    }
-    return true;
+  derivationCreateMultiple(request) {
+    return this.#koniState.keyringService.context.derivationCreateMultiple(request);
   }
-  derivationCreateV3({
-    address: parentAddress
-  }) {
-    const parentPair = keyring.getPair(parentAddress);
-    const isEvm = parentPair.type === 'ethereum';
-    if (parentPair.isLocked) {
-      keyring.unlockPair(parentPair.address);
-    }
-    const pairs = keyring.getPairs();
-    const children = pairs.filter(p => p.meta.parentAddress === parentAddress);
-    const name = `Account ${pairs.length}`;
-    let index = isEvm ? 1 : 0;
-    let valid = false;
-    do {
-      const exist = children.find(p => p.meta.suri === `//${index}`);
-      if (exist) {
-        index++;
-      } else {
-        valid = true;
-      }
-    } while (!valid);
-    const meta = {
-      name,
-      parentAddress,
-      suri: `//${index}`
-    };
-    const childPair = isEvm ? parentPair.deriveEvm(index, meta) : parentPair.derive(meta.suri, meta);
-    const address = childPair.address;
-    this._saveCurrentAccountAddress(address, () => {
-      keyring.addPair(childPair, true);
-      this._addAddressToAuthList(address, true);
-    });
+  derivationCreateV3(request) {
+    const rs = this.#koniState.keyringService.context.derivationAccountProxyCreate(request);
     if (this.#alwaysLock) {
       this.keyringLock();
     }
-    return true;
+    return rs;
   }
-  validateDerivePath({
-    parentAddress,
-    suri
-  }) {
-    const parentPair = keyring.getPair(parentAddress);
-    const isEvm = parentPair.type === 'ethereum';
-    if (parentPair.isLocked) {
-      keyring.unlockPair(parentPair.address);
-    }
-    const meta = {
-      parentAddress
-    };
-    let childPair;
-    if (isEvm) {
-      let index = 0;
-      try {
-        const reg = /^\d+$/;
-        const path = suri.split('//')[1];
-        if (reg.test(path)) {
-          index = parseInt(path);
-        }
-      } catch (e) {}
-      if (!index) {
-        throw Error(t('Invalid derive path'));
-      }
-      meta.suri = `//${index}`;
-      childPair = parentPair.deriveEvm(index, meta);
-    } else {
-      meta.suri = suri;
-      childPair = parentPair.derive(suri, meta);
-    }
-    return {
-      address: childPair.address,
-      suri: meta.suri
-    };
+  validateDerivePath(request) {
+    return this.#koniState.keyringService.context.validateDerivePath(request);
   }
-  getListDeriveAccounts({
-    limit,
-    page,
-    parentAddress
-  }) {
-    const parentPair = keyring.getPair(parentAddress);
-    const isEvm = parentPair.type === 'ethereum';
-    if (parentPair.isLocked) {
-      keyring.unlockPair(parentPair.address);
-    }
-    const start = (page - 1) * limit + (isEvm ? 1 : 0);
-    const end = start + limit;
-    const result = [];
-    for (let i = start; i < end; i++) {
-      const suri = `//${i}`;
-      const pair = isEvm ? parentPair.deriveEvm(i, {}) : parentPair.derive(suri, {});
-      result.push({
-        address: pair.address,
-        suri: suri
-      });
-    }
-    return {
-      result: result
-    };
+  getDeriveSuggestion(request) {
+    return this.#koniState.keyringService.context.getDeriveSuggestion(request);
+  }
+  getListDeriveAccounts(request) {
+    return this.#koniState.keyringService.context.getListDeriveAccounts(request);
   }
 
   // ChainService -------------------------------------------------
@@ -3563,7 +2658,7 @@ export default class KoniExtension {
       }
       const result = await this.#koniState.enableMantaPay(true, address, password, mnemonic.result);
       this.#skipAutoLock = true;
-      await this.saveCurrentAccountAddress({
+      await this.saveCurrentAccountProxy({
         address
       });
       const unsubSyncProgress = await ((_this$koniState$chain = this.#koniState.chainService) === null || _this$koniState$chain === void 0 ? void 0 : (_this$koniState$chain2 = _this$koniState$chain.mantaPay) === null || _this$koniState$chain2 === void 0 ? void 0 : _this$koniState$chain2.subscribeSyncProgress());
@@ -3602,7 +2697,7 @@ export default class KoniExtension {
       return;
     }
     this.#skipAutoLock = true;
-    await this.saveCurrentAccountAddress({
+    await this.saveCurrentAccountProxy({
       address
     });
     const unsubSyncProgress = await ((_this$koniState$chain5 = this.#koniState.chainService) === null || _this$koniState$chain5 === void 0 ? void 0 : (_this$koniState$chain6 = _this$koniState$chain5.mantaPay) === null || _this$koniState$chain6 === void 0 ? void 0 : _this$koniState$chain6.subscribeSyncProgress());
@@ -3631,6 +2726,21 @@ export default class KoniExtension {
   async disableMantaPay(address) {
     return this.#koniState.disableMantaPay(address);
   }
+  async isTonBounceableAddress({
+    address,
+    chain
+  }) {
+    try {
+      const tonApi = this.#koniState.getTonApi(chain);
+      const state = await tonApi.getAccountState(address);
+      const isActive = state === 'active';
+      const isBounceable = isBounceableAddress(address);
+      return !isActive && isBounceable;
+    } catch (error) {
+      console.error(`Failed to validate address ${address} on chain ${chain}:`, error);
+      return false;
+    }
+  }
   subscribeMantaPayConfig(id, port) {
     const cb = createSubscription(id, port);
     const mantaPayConfigSubscription = this.#koniState.subscribeMantaPayConfig().subscribe({
@@ -3712,11 +2822,11 @@ export default class KoniExtension {
 
   /// Inject account
   addInjects(request) {
-    this.#koniState.keyringService.addInjectAccounts(request.accounts);
+    this.#koniState.keyringService.context.addInjectAccounts(request.accounts);
     return true;
   }
   removeInjects(request) {
-    this.#koniState.keyringService.removeInjectAccounts(request.addresses);
+    this.#koniState.keyringService.context.removeInjectAccounts(request.addresses);
     return true;
   }
   async subscribeYieldPoolInfo(id, port) {
@@ -4202,22 +3312,8 @@ export default class KoniExtension {
       case 'pri(ping)':
         return 'pong';
       /// Clone from PolkadotJs
-      case 'pri(accounts.create.external)':
-        return this.accountsCreateExternal(request);
-      case 'pri(accounts.create.hardware)':
-        return this.accountsCreateHardware(request);
-      case 'pri(accounts.create.suri)':
-        return this.accountsCreateSuri(request);
-      case 'pri(accounts.changePassword)':
-        return this.accountsChangePassword(request);
-      case 'pri(accounts.export)':
+      case 'pri(accounts.export.json)':
         return this.accountsExport(request);
-      case 'pri(accounts.show)':
-        return this.accountsShow(request);
-      case 'pri(accounts.subscribe)':
-        return this.accountsSubscribe(id, port);
-      case 'pri(accounts.validate)':
-        return this.accountsValidate(request);
       case 'pri(metadata.approve)':
         return this.metadataApprove(request);
       case 'pri(metadata.get)':
@@ -4228,20 +3324,6 @@ export default class KoniExtension {
         return this.metadataReject(request);
       case 'pri(metadata.requests)':
         return this.metadataSubscribe(id, port);
-      case 'pri(derivation.create)':
-        return this.derivationCreate(request);
-      case 'pri(derivation.validate)':
-        return this.derivationValidate(request);
-      case 'pri(json.restore)':
-        return this.jsonRestore(request);
-      case 'pri(json.batchRestore)':
-        return this.batchRestore(request);
-      case 'pri(json.account.info)':
-        return this.jsonGetAccountInfo(request);
-      case 'pri(seed.create)':
-        return this.seedCreate(request);
-      case 'pri(seed.validate)':
-        return this.seedValidate(request);
       case 'pri(signing.approve.signature)':
         return this.signingApproveSignature(request);
       case 'pri(signing.cancel)':
@@ -4320,14 +3402,6 @@ export default class KoniExtension {
         return this.getCrowdloanContributions(request);
       case 'pri(crowdloan.getSubscription)':
         return this.subscribeCrowdloan(id, port);
-      case 'pri(derivation.createV2)':
-        return this.derivationCreateV2(request);
-      case 'pri(accounts.batchExportV2)':
-        return this.batchExportV2(request);
-      case 'pri(json.restoreV2)':
-        return await this.jsonRestoreV2(request);
-      case 'pri(json.batchRestoreV2)':
-        return await this.batchRestoreV2(request);
       case 'pri(nft.getNft)':
         return await this.getNft();
       case 'pri(nft.getSubscription)':
@@ -4403,7 +3477,7 @@ export default class KoniExtension {
       /* Account management */
       // Add account
       case 'pri(accounts.create.suriV2)':
-        return await this.accountsCreateSuriV2(request);
+        return this.accountsCreateSuriV2(request);
       case 'pri(accounts.create.externalV2)':
         return await this.accountsCreateExternalV2(request);
       case 'pri(accounts.create.hardwareV2)':
@@ -4412,6 +3486,14 @@ export default class KoniExtension {
         return await this.accountsCreateHardwareMultiple(request);
       case 'pri(accounts.create.withSecret)':
         return await this.accountsCreateWithSecret(request);
+      case 'pri(accounts.json.info)':
+        return this.parseInfoSingleJson(request);
+      case 'pri(accounts.json.restoreV2)':
+        return this.jsonRestoreV2(request);
+      case 'pri(accounts.json.batchInfo)':
+        return this.parseInfoMultiJson(request);
+      case 'pri(accounts.json.batchRestoreV2)':
+        return this.batchRestoreV2(request);
       case 'pri(seed.createV2)':
         return this.seedCreateV2(request);
 
@@ -4420,43 +3502,54 @@ export default class KoniExtension {
         return await this.accountsForgetOverride(request);
 
       // Validate account
-      case 'pri(seed.validateV2)':
+      case 'pri(accounts.validate.seed)':
         return this.seedValidateV2(request);
-      case 'pri(privateKey.validateV2)':
-        return this.metamaskPrivateKeyValidateV2(request);
-      case 'pri(accounts.checkPublicAndSecretKey)':
+      case 'pri(accounts.validate.privateKey)':
+        return this.privateKeyValidateV2(request);
+      case 'pri(accounts.validate.substrate.publicAndPrivateKey)':
         return this.checkPublicAndSecretKey(request);
+      case 'pri(accounts.validate.name)':
+        return this.checkNameExists(request);
+      case 'pri(accounts.validate.bounceable)':
+        return this.isTonBounceableAddress(request);
 
       // Export account
-      case 'pri(accounts.exportPrivateKey)':
+      case 'pri(accounts.export.privateKey)':
         return this.accountExportPrivateKey(request);
+      case 'pri(accounts.export.json.batch)':
+        return this.batchExportV2(request);
+      case 'pri(accounts.export.mnemonic)':
+        return this.exportAccountProxyMnemonic(request);
 
       // Subscribe account
-      case 'pri(accounts.subscribeWithCurrentAddress)':
+      case 'pri(accounts.subscribeWithCurrentProxy)':
         return await this.accountsGetAllWithCurrentAddress(id, port);
       case 'pri(accounts.subscribeAccountsInputAddress)':
-        return this.accountsGetAll(id, port);
+        return this.subscribeInputAddressData(request, id, port);
 
       // Save current account
-      case 'pri(currentAccount.saveAddress)':
-        return await this.saveCurrentAccountAddress(request);
-      case 'pri(accounts.updateCurrentAddress)':
-        return this.updateCurrentAccountAddress(request);
+      case 'pri(accounts.saveCurrentProxy)':
+        return await this.saveCurrentAccountProxy(request);
 
       // Edit account
       case 'pri(accounts.edit)':
         return this.accountsEdit(request);
+      // Ton change wallet contract version
+      case 'pri(accounts.ton.version.map)':
+        return this.tonGetAllTonWalletContractVersion(request);
+      case 'pri(accounts.ton.version.change)':
+        return this.tonAccountChangeWalletContractVersion(request);
 
       // Save contact address
-      case 'pri(accounts.saveRecent)':
+      case 'pri(addressBook.saveRecent)':
         return this.saveRecentAccount(request);
-      case 'pri(accounts.editContact)':
+      case 'pri(addressBook.edit)':
         return this.editContactAccount(request);
-      case 'pri(accounts.deleteContact)':
+      case 'pri(addressBook.delete)':
         return this.deleteContactAccount(request);
 
       // Subscribe address
-      case 'pri(accounts.subscribeAddresses)':
+      case 'pri(addressBook.subscribe)':
         return this.subscribeAddresses(id, port);
       case 'pri(accounts.resolveDomainToAddress)':
         return await this.resolveDomainByAddress(request);
@@ -4514,8 +3607,6 @@ export default class KoniExtension {
         return await this.updateAssetSetting(request);
       case 'pri(transfer.getMaxTransferable)':
         return this.getMaxTransferable(request);
-      case 'pri(transfer.subscribeMaxTransferable)':
-        return this.getMaxTransferable(request);
       case 'pri(freeBalance.get)':
         return this.getAddressTransferableBalance(request);
       case 'pri(freeBalance.subscribe)':
@@ -4524,8 +3615,6 @@ export default class KoniExtension {
         return this.cancelSubscription(request);
       case 'pri(chainService.recoverSubstrateApi)':
         return this.recoverDotSamaApi(request);
-      case 'pri(accounts.get.meta)':
-        return this.getAccountMeta(request);
 
       /// Send NFT
       case 'pri(evmNft.submitTransaction)':
@@ -4558,12 +3647,14 @@ export default class KoniExtension {
         return this.rejectExternalRequest(request);
       case 'pri(account.external.resolve)':
         return this.resolveQrTransfer(request);
-      case 'pri(accounts.tie)':
-        return this.accountsTie2(request);
       case 'pri(confirmations.subscribe)':
         return this.subscribeConfirmations(id, port);
+      case 'pri(confirmationsTon.subscribe)':
+        return this.subscribeConfirmationsTon(id, port);
       case 'pri(confirmations.complete)':
         return await this.completeConfirmation(request);
+      case 'pri(confirmationsTon.complete)':
+        return await this.completeConfirmationTon(request);
 
       /// Stake
       case 'pri(bonding.getBondingOptions)':
@@ -4624,14 +3715,16 @@ export default class KoniExtension {
         return this.signingApprovePasswordV2(request);
 
       /// Derive account
-      case 'pri(derivation.validateV2)':
+      case 'pri(accounts.derive.validateV2)':
         return this.validateDerivePath(request);
-      case 'pri(derivation.getList)':
+      case 'pri(accounts.derive.getList)':
         return this.getListDeriveAccounts(request);
-      case 'pri(derivation.create.multiple)':
+      case 'pri(accounts.derive.create.multiple)':
         return this.derivationCreateMultiple(request);
-      case 'pri(derivation.createV3)':
+      case 'pri(accounts.derive.createV3)':
         return this.derivationCreateV3(request);
+      case 'pri(accounts.derive.suggestion)':
+        return this.getDeriveSuggestion(request);
 
       // Transaction
       case 'pri(transactions.getOne)':
@@ -4737,6 +3830,8 @@ export default class KoniExtension {
         return this.#koniState.migrateMV3LocalStorage(request);
       case 'pri(database.setLocalStorage)':
         return this.#koniState.setStorageFromWS(request);
+      case 'pri(database.getLocalStorage)':
+        return this.#koniState.getStorageFromWS(request);
       /* Database */
 
       /* Swap service */