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

package/cjs/koni/background/handlers/Extension.js

@@ -4,7 +4,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = exports.SEED_LENGTHS = exports.SEED_DEFAULT_LENGTH = void 0;
+exports.default = void 0;
 exports.isJsonPayload = isJsonPayload;
 var _common = require("@ethereumjs/common");
 var _tx = require("@ethereumjs/tx");
@@ -26,12 +26,14 @@ var _bonding = require("@subwallet/extension-base/koni/api/staking/bonding");
 var _paraChain = require("@subwallet/extension-base/koni/api/staking/bonding/paraChain");
 var _relayChain = require("@subwallet/extension-base/koni/api/staking/bonding/relayChain");
 var _utils2 = require("@subwallet/extension-base/koni/api/yield/helper/utils");
+var _utils3 = require("@subwallet/extension-base/services/balance-service/helpers/subscribe/ton/utils");
 var _smartContract = require("@subwallet/extension-base/services/balance-service/transfer/smart-contract");
 var _token = require("@subwallet/extension-base/services/balance-service/transfer/token");
+var _tonTransfer = require("@subwallet/extension-base/services/balance-service/transfer/ton-transfer");
 var _xcm = require("@subwallet/extension-base/services/balance-service/transfer/xcm");
 var _constants2 = require("@subwallet/extension-base/services/chain-service/constants");
 var _types = require("@subwallet/extension-base/services/chain-service/types");
-var _utils3 = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils4 = require("@subwallet/extension-base/services/chain-service/utils");
 var _constants3 = require("@subwallet/extension-base/services/request-service/constants");
 var _constants4 = require("@subwallet/extension-base/services/setting-service/constants");
 var _constants5 = require("@subwallet/extension-base/services/wallet-connect-service/constants");
@@ -39,49 +41,22 @@ var _helpers2 = require("@subwallet/extension-base/services/wallet-connect-servi
 var _storage = require("@subwallet/extension-base/storage");
 var _stores = require("@subwallet/extension-base/stores");
 var _types2 = require("@subwallet/extension-base/types");
-var _utils4 = require("@subwallet/extension-base/utils");
+var _utils5 = require("@subwallet/extension-base/utils");
 var _parseTransaction2 = require("@subwallet/extension-base/utils/eth/parseTransaction");
 var _extensionChains = require("@subwallet/extension-chains");
 var _keyring = require("@subwallet/keyring");
+var _types3 = require("@subwallet/keyring/types");
 var _uiKeyring = require("@subwallet/ui-keyring");
-var _utils5 = require("@walletconnect/utils");
+var _utils6 = require("@walletconnect/utils");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 var _i18next = require("i18next");
 var _rxjs = require("rxjs");
-var _types3 = require("@polkadot/types");
+var _types4 = require("@polkadot/types");
 var _util = require("@polkadot/util");
 var _utilCrypto = require("@polkadot/util-crypto");
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-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(_ref => {
-    let {
-      json: {
-        address,
-        meta
-      },
-      type
-    } = _ref;
-    return {
-      address,
-      ...meta,
-      type
-    };
-  });
-}
-const ACCOUNT_ALL_JSON = {
-  address: _constants.ALL_ACCOUNT_KEY,
-  name: 'All'
-};
-const SEED_DEFAULT_LENGTH = 12;
-exports.SEED_DEFAULT_LENGTH = SEED_DEFAULT_LENGTH;
-const SEED_LENGTHS = [12, 15, 18, 21, 24];
-exports.SEED_LENGTHS = SEED_LENGTHS;
 function isJsonPayload(value) {
   return value.genesisHash !== undefined;
 }
@@ -92,6 +67,11 @@ 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 _rxjs.Subject();
   constructor(state) {
     this.#koniState = state;
@@ -130,132 +110,28 @@ class KoniExtension {
       next: updateTimeAutoLock
     });
   }
-
-  /// Clone from PolkadotJs
-  accountsCreateExternal(_ref2) {
-    let {
-      address,
-      genesisHash,
-      name
-    } = _ref2;
-    _uiKeyring.keyring.addExternal(address, {
-      genesisHash,
-      name
-    });
-    return true;
-  }
-  accountsCreateHardware(_ref3) {
-    let {
-      accountIndex,
-      address,
-      addressOffset,
-      genesisHash,
-      hardwareType,
-      name
-    } = _ref3;
-    _uiKeyring.keyring.addHardware(address, hardwareType, {
-      accountIndex,
-      addressOffset,
-      genesisHash,
-      name
-    });
-    return true;
-  }
-  accountsCreateSuri(_ref4) {
-    let {
-      genesisHash,
-      name,
-      suri,
-      type
-    } = _ref4;
-    _uiKeyring.keyring.addUri(getSuri(suri, type), {
-      genesisHash,
-      name
-    }, type);
-    return true;
+  accountsEdit(request) {
+    return this.#koniState.keyringService.context.accountsEdit(request);
   }
-  accountsChangePassword(_ref5) {
-    let {
-      address,
-      newPass,
-      oldPass
-    } = _ref5;
-    const pair = _uiKeyring.keyring.getPair(address);
-    (0, _util.assert)(pair, (0, _i18next.t)('Unable to find account'));
-    try {
-      if (!pair.isLocked) {
-        pair.lock();
-      }
-      pair.decodePkcs8(oldPass);
-    } catch (error) {
-      throw new Error((0, _i18next.t)('Wrong password'));
-    }
-    _uiKeyring.keyring.encryptAccount(pair, newPass);
-    return true;
+  tonGetAllTonWalletContractVersion(request) {
+    return this.#koniState.keyringService.context.tonGetAllTonWalletContractVersion(request);
   }
-  accountsEdit(_ref6) {
-    let {
-      address,
-      name
-    } = _ref6;
-    const pair = _uiKeyring.keyring.getPair(address);
-    (0, _util.assert)(pair, (0, _i18next.t)('Unable to find account'));
-    _uiKeyring.keyring.saveAccountMeta(pair, {
-      ...pair.meta,
-      name
-    });
-    return true;
+  tonAccountChangeWalletContractVersion(request) {
+    return this.#koniState.keyringService.context.tonAccountChangeWalletContractVersion(request);
   }
-  accountsExport(_ref7) {
+  accountsExport(_ref) {
     let {
       address,
       password
-    } = _ref7;
+    } = _ref;
     return {
       exportedJson: _uiKeyring.keyring.backupAccount(_uiKeyring.keyring.getPair(address), password)
     };
   }
-  accountsShow(_ref8) {
-    let {
-      address,
-      isShowing
-    } = _ref8;
-    const pair = _uiKeyring.keyring.getPair(address);
-    (0, _util.assert)(pair, (0, _i18next.t)('Unable to find account'));
-    _uiKeyring.keyring.saveAccountMeta(pair, {
-      ...pair.meta,
-      isHidden: !isShowing
-    });
-    return true;
-  }
-  accountsValidate(_ref9) {
-    let {
-      address,
-      password
-    } = _ref9;
-    try {
-      _uiKeyring.keyring.backupAccount(_uiKeyring.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 = (0, _subscriptions.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(_ref10) {
+  metadataApprove(_ref2) {
     let {
       id
-    } = _ref10;
+    } = _ref2;
     const queued = this.#koniState.getMetaRequest(id);
     (0, _util.assert)(queued, (0, _i18next.t)('Unable to proceed. Please try again'));
     const {
@@ -272,10 +148,10 @@ class KoniExtension {
   metadataList() {
     return this.#koniState.knownMetadata;
   }
-  metadataReject(_ref11) {
+  metadataReject(_ref3) {
     let {
       id
-    } = _ref11;
+    } = _ref3;
     const queued = this.#koniState.getMetaRequest(id);
     (0, _util.assert)(queued, (0, _i18next.t)('Unable to proceed. Please try again'));
     const {
@@ -293,93 +169,14 @@ class KoniExtension {
     });
     return this.#koniState.metaSubject.value;
   }
-  jsonRestore(_ref12) {
-    let {
-      file,
-      password
-    } = _ref12;
-    try {
-      _uiKeyring.keyring.restoreAccount(file, password, true);
-    } catch (error) {
-      throw new Error(error.message);
-    }
-  }
-  batchRestore(_ref13) {
-    let {
-      file,
-      password
-    } = _ref13;
-    try {
-      _uiKeyring.keyring.restoreAccounts(file, password);
-    } catch (error) {
-      throw new Error(error.message);
-    }
-  }
-  jsonGetAccountInfo(json) {
-    try {
-      const {
-        address,
-        meta: {
-          genesisHash,
-          name
-        },
-        type
-      } = _uiKeyring.keyring.createFromJson(json);
-      return {
-        address,
-        genesisHash,
-        name,
-        type
-      };
-    } catch (e) {
-      console.error(e);
-      throw new Error(e.message);
-    }
-  }
-  seedCreate(_ref14) {
-    let {
-      length = SEED_DEFAULT_LENGTH,
-      seed: _seed,
-      type
-    } = _ref14;
-    const seed = _seed || (0, _utilCrypto.mnemonicGenerate)(length);
-    return {
-      address: _uiKeyring.keyring.createFromUri(getSuri(seed, type), {}, type).address,
-      seed
-    };
-  }
-  seedValidate(_ref15) {
-    let {
-      suri,
-      type
-    } = _ref15;
-    const {
-      phrase
-    } = (0, _utilCrypto.keyExtractSuri)(suri);
-    if ((0, _util.isHex)(phrase)) {
-      (0, _util.assert)((0, _util.isHex)(phrase, 256), (0, _i18next.t)('Invalid seed phrase. Please try again.'));
-    } else {
-      // sadly isHex detects as string, so we need a cast here
-      (0, _util.assert)(SEED_LENGTHS.includes(phrase.split(' ').length), (0, _i18next.t)('Seed phrase needs to contain {{x}} words', {
-        replace: {
-          x: SEED_LENGTHS.join(', ')
-        }
-      }));
-      (0, _util.assert)((0, _utilCrypto.mnemonicValidate)(phrase), (0, _i18next.t)('Invalid seed phrase. Please try again.'));
-    }
-    return {
-      address: _uiKeyring.keyring.createFromUri(getSuri(suri, type), {}, type).address,
-      suri
-    };
-  }
 
   // TODO: move to request service
-  signingApproveSignature(_ref16) {
+  signingApproveSignature(_ref4) {
     let {
       id,
       signature,
       signedTransaction
-    } = _ref16;
+    } = _ref4;
     const queued = this.#koniState.getSignRequest(id);
     (0, _util.assert)(queued, (0, _i18next.t)('Unable to proceed. Please try again'));
     const {
@@ -394,16 +191,16 @@ class KoniExtension {
   }
 
   // TODO: move to request service
-  signingCancel(_ref17) {
+  signingCancel(_ref5) {
     let {
       id
-    } = _ref17;
+    } = _ref5;
     const queued = this.#koniState.getSignRequest(id);
     (0, _util.assert)(queued, (0, _i18next.t)('Unable to proceed. Please try again'));
     const {
       reject
     } = queued;
-    reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.USER_REJECT_REQUEST));
+    reject(new _TransactionError.TransactionError(_types2.BasicTxErrorType.USER_REJECT_REQUEST));
     return true;
   }
 
@@ -417,12 +214,12 @@ class KoniExtension {
     });
     return this.#koniState.signSubject.value;
   }
-  windowOpen(_ref18) {
+  windowOpen(_ref6) {
     let {
       allowedPath: path,
       params,
       subPath
-    } = _ref18;
+    } = _ref6;
     let paramString = '';
     if (params) {
       paramString += '?';
@@ -444,52 +241,6 @@ class KoniExtension {
     }));
     return true;
   }
-  derive(parentAddress, suri, password, metadata) {
-    const parentPair = _uiKeyring.keyring.getPair(parentAddress);
-    try {
-      parentPair.decodePkcs8(password);
-    } catch (e) {
-      throw new Error((0, _i18next.t)('Wrong password'));
-    }
-    try {
-      return parentPair.derive(suri, metadata);
-    } catch (err) {
-      throw new Error((0, _i18next.t)('"{{suri}}" is not a valid derivation path', {
-        replace: {
-          suri
-        }
-      }));
-    }
-  }
-  derivationValidate(_ref19) {
-    let {
-      parentAddress,
-      parentPassword,
-      suri
-    } = _ref19;
-    const childPair = this.derive(parentAddress, suri, parentPassword, {});
-    return {
-      address: childPair.address,
-      suri
-    };
-  }
-  derivationCreate(_ref20) {
-    let {
-      genesisHash,
-      name,
-      parentAddress,
-      parentPassword,
-      suri
-    } = _ref20;
-    const childPair = this.derive(parentAddress, suri, parentPassword, {
-      genesisHash,
-      name,
-      parentAddress,
-      suri
-    });
-    _uiKeyring.keyring.addPair(childPair, true);
-    return true;
-  }
 
   ///
 
@@ -499,79 +250,103 @@ class KoniExtension {
   createUnsubscriptionHandle(id, unsubscribe) {
     this.#koniState.createUnsubscriptionHandle(id, unsubscribe);
   }
-  decodeAddress = (key, ignoreChecksum, ss58Format) => {
-    return _uiKeyring.keyring.decodeAddress(key, ignoreChecksum, ss58Format);
-  };
-  encodeAddress = (key, ss58Format) => {
-    return _uiKeyring.keyring.encodeAddress(key, ss58Format);
-  };
-  accountExportPrivateKey(_ref21) {
-    let {
-      address,
-      password
-    } = _ref21;
-    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 = (0, _subscriptions.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 ? [(0, _utils5.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 = (0, _rxjs.combineLatest)({
+      accountProxies: accountProxyMapObservable,
+      currentAccount: currentAccountInfoObservable
+    }).subscribe(_ref7 => {
+      let {
+        accountProxies,
+        currentAccount
+      } = _ref7;
+      const transformedAccounts = Object.values(accountProxies);
+      responseData.accounts = transformedAccounts !== null && transformedAccounts !== void 0 && transformedAccounts.length ? [(0, _utils5.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 = (0, _subscriptions.createSubscription)(id, port);
-    const subscription = _uiKeyring.keyring.keyringOption.optionsSubject.subscribe(options => {
-      const optionsInputAddress = {
-        options
+    const combineFunction = async (chainInfoMap, accountProxyMap, _contacts) => {
+      const accountProxies = Object.values(accountProxyMap);
+      const contacts = (0, _utils5.transformAddresses)(_contacts);
+      const chainInfo = chainInfoMap[chain];
+      const substrateApi = this.#koniState.chainService.getSubstrateApi(chain);
+      const rs = await (0, _utils5._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 = (0, _rxjs.combineLatest)({
+      chainInfoMap: chainInfoMapObservable,
+      accountProxies: accountObservable,
+      contacts: contactObservable
+    }).subscribe(_ref8 => {
+      let {
+        accountProxies,
+        chainInfoMap,
+        contacts
+      } = _ref8;
+      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 = (0, _subscriptions.createSubscription)(id, port);
     let old = '';
-    const subscription = this.#koniState.keyringService.addressesSubject.subscribe(subjectInfo => {
-      const addresses = (0, _utils4.convertSubjectInfoToAddresses)(subjectInfo);
+    const subscription = this.#koniState.keyringService.context.observable.contacts.subscribe(subjectInfo => {
+      const addresses = (0, _utils5.transformAddresses)(subjectInfo);
       const _new = JSON.stringify(addresses);
       if (old !== _new) {
         _cb({
@@ -580,22 +355,28 @@ 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: (0, _utils4.convertSubjectInfoToAddresses)(subjectInfo)
+      addresses: (0, _utils5.transformAccounts)(subjectInfo)
     };
   }
-  saveRecentAccount(_ref22) {
+
+  /**
+   * @todo: move to keyring context
+   * */
+  saveRecentAccount(_ref9) {
     let {
       accountId,
       chain
-    } = _ref22;
-    if ((0, _utilCrypto.isAddress)(accountId)) {
-      const address = (0, _utils4.reformatAddress)(accountId);
+    } = _ref9;
+    if ((0, _keyring.isAddress)(accountId)) {
+      const address = (0, _utils5.reformatAddress)(accountId);
       const account = _uiKeyring.keyring.getAccount(address);
       const contact = _uiKeyring.keyring.getAddress(address, 'address');
       if (account) {
@@ -618,7 +399,7 @@ class KoniExtension {
           }
         }
         metadata.recentChainSlugs = recentChainSlugs;
-        const result = _uiKeyring.keyring.addresses.add(new _stores.AccountsStore(), address, {
+        const result = _uiKeyring.keyring.addresses.add(new _stores.AccountsStore(), address, address, {
           address: address,
           meta: metadata
         });
@@ -631,25 +412,33 @@ class KoniExtension {
       throw Error((0, _i18next.t)('This is not an address'));
     }
   }
-  editContactAccount(_ref23) {
+
+  /**
+   * @todo: move to keyring context
+   * */
+  editContactAccount(_ref10) {
     let {
       address,
       meta
-    } = _ref23;
-    if ((0, _utilCrypto.isAddress)(address)) {
-      const _address = (0, _utils4.reformatAddress)(address);
+    } = _ref10;
+    if ((0, _keyring.isAddress)(address)) {
+      const _address = (0, _utils5.reformatAddress)(address);
       _uiKeyring.keyring.saveAddress(_address, meta);
       return true;
     } else {
       throw Error((0, _i18next.t)('This is not an address'));
     }
   }
-  deleteContactAccount(_ref24) {
+
+  /**
+   * @todo: move to keyring context
+   * */
+  deleteContactAccount(_ref11) {
     let {
       address
-    } = _ref24;
-    if ((0, _utilCrypto.isAddress)(address)) {
-      const _address = (0, _utils4.reformatAddress)(address);
+    } = _ref11;
+    if ((0, _keyring.isAddress)(address)) {
+      const _address = (0, _utils5.reformatAddress)(address);
       _uiKeyring.keyring.forgetAddress(_address);
       return true;
     } else {
@@ -660,7 +449,7 @@ 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 => {
@@ -696,11 +485,11 @@ class KoniExtension {
       list: authList
     };
   }
-  authorizeApproveV2(_ref25) {
+  authorizeApproveV2(_ref12) {
     let {
       accounts,
       id
-    } = _ref25;
+    } = _ref12;
     const queued = this.#koniState.getAuthRequestV2(id);
     (0, _util.assert)(queued, (0, _i18next.t)('Unable to proceed. Please try again'));
     const {
@@ -712,10 +501,10 @@ class KoniExtension {
     });
     return true;
   }
-  authorizeRejectV2(_ref26) {
+  authorizeRejectV2(_ref13) {
     let {
       id
-    } = _ref26;
+    } = _ref13;
     const queued = this.#koniState.getAuthRequestV2(id);
     (0, _util.assert)(queued, (0, _i18next.t)('Unable to proceed. Please try again'));
     const {
@@ -724,10 +513,10 @@ class KoniExtension {
     reject(new Error('Rejected'));
     return true;
   }
-  authorizeCancelV2(_ref27) {
+  authorizeCancelV2(_ref14) {
     let {
       id
-    } = _ref27;
+    } = _ref14;
     const queued = this.#koniState.getAuthRequestV2(id);
     (0, _util.assert)(queued, (0, _i18next.t)('Unable to proceed. Please try again'));
     const {
@@ -776,37 +565,61 @@ 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 (0, _utils5.transformAccounts)(storedAccounts);
   }
-  isAddressValidWithAuthType(address, accountAuthType) {
-    if (accountAuthType === 'substrate') {
-      return !(0, _utilCrypto.isEthereumAddress)(address);
-    } else if (accountAuthType === 'evm') {
-      return (0, _utilCrypto.isEthereumAddress)(address);
-    }
-    return true;
+  isAddressValidWithAuthType(address, accountAuthTypes) {
+    const type = (0, _keyring.getKeypairTypeByAddress)(address);
+    const validTypes = {
+      evm: _types3.EthereumKeypairTypes,
+      substrate: _types3.SubstrateKeypairTypes,
+      ton: _types3.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 => !(0, _utilCrypto.isEthereumAddress)(address));
-    } else if (accountAuthType === 'evm') {
-      return accounts.filter(address => (0, _utilCrypto.isEthereumAddress)(address));
-    } else {
-      return accounts;
+  filterAccountsByAccountAuthType(accounts, accountAuthTypes) {
+    if (!accountAuthTypes) {
+      return [];
     }
+    return accountAuthTypes.reduce((list, accountAuthType) => {
+      if (accountAuthType === 'evm') {
+        accounts.forEach(_ref15 => {
+          let {
+            address
+          } = _ref15;
+          return (0, _utilCrypto.isEthereumAddress)(address) && list.push(address);
+        });
+      } else if (accountAuthType === 'substrate') {
+        accounts.forEach(_ref16 => {
+          let {
+            address
+          } = _ref16;
+          return (0, _keyring.isSubstrateAddress)(address) && list.push(address);
+        });
+      } else if (accountAuthType === 'ton') {
+        accounts.forEach(_ref17 => {
+          let {
+            address
+          } = _ref17;
+          return (0, _keyring.isTonAddress)(address) && list.push(address);
+        });
+      }
+      return list;
+    }, []);
   }
   _changeAuthorizationAll(connectValue, callBack) {
     this.#koniState.getAuthorize(value => {
       (0, _util.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;
         });
@@ -829,8 +642,8 @@ class KoniExtension {
   _changeAuthorization(url, connectValue, callBack) {
     this.#koniState.getAuthorize(value => {
       (0, _util.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;
       });
@@ -865,7 +678,7 @@ class KoniExtension {
   _changeAuthorizationPerAcc(address, connectValue, url, callBack) {
     this.#koniState.getAuthorize(value => {
       (0, _util.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);
@@ -948,10 +761,10 @@ class KoniExtension {
     this.#koniState.updateSetting('theme', data);
     return true;
   }
-  setCamera(_ref28) {
+  setCamera(_ref18) {
     let {
       camera
-    } = _ref28;
+    } = _ref18;
     this.#koniState.updateSetting('camera', camera);
     return true;
   }
@@ -959,17 +772,17 @@ class KoniExtension {
     this.#koniState.updateSetting('browserConfirmationType', data);
     return true;
   }
-  setAutoLockTime(_ref29) {
+  setAutoLockTime(_ref19) {
     let {
       autoLockTime
-    } = _ref29;
+    } = _ref19;
     this.#koniState.updateSetting('timeAutoLock', autoLockTime);
     return true;
   }
-  setUnlockType(_ref30) {
+  setUnlockType(_ref20) {
     let {
       unlockType
-    } = _ref30;
+    } = _ref20;
     this.#koniState.updateSetting('unlockType', unlockType);
     return true;
   }
@@ -986,31 +799,31 @@ class KoniExtension {
     });
     return await this.getSettings();
   }
-  setEnableChainPatrol(_ref31) {
+  setEnableChainPatrol(_ref21) {
     let {
       enable
-    } = _ref31;
+    } = _ref21;
     this.#koniState.updateSetting('enableChainPatrol', enable);
     return true;
   }
-  setShowZeroBalance(_ref32) {
+  setShowZeroBalance(_ref22) {
     let {
       show
-    } = _ref32;
+    } = _ref22;
     this.#koniState.updateSetting('isShowZeroBalance', show);
     return true;
   }
-  setLanguage(_ref33) {
+  setLanguage(_ref23) {
     let {
       language
-    } = _ref33;
+    } = _ref23;
     this.#koniState.updateSetting('language', language);
     return true;
   }
-  setShowBalance(_ref34) {
+  setShowBalance(_ref24) {
     let {
       enable
-    } = _ref34;
+    } = _ref24;
     this.#koniState.updateSetting('isShowBalance', enable);
     return true;
   }
@@ -1027,39 +840,10 @@ class KoniExtension {
     });
     return await this.#koniState.getAuthList();
   }
-  _saveCurrentAccountAddress(address, callback) {
-    let accountInfo = this.#koniState.keyringService.currentAccount;
-    if (!accountInfo) {
-      accountInfo = {
-        address,
-        currentGenesisHash: _constants.ALL_GENESIS_HASH,
-        allGenesisHash: _constants.ALL_GENESIS_HASH || undefined
-      };
-    } else {
-      accountInfo.address = address;
-      if (address !== _constants.ALL_ACCOUNT_KEY) {
-        try {
-          const currentKeyPair = _uiKeyring.keyring.getPair(address);
-          accountInfo.currentGenesisHash = (currentKeyPair === null || currentKeyPair === void 0 ? void 0 : currentKeyPair.meta.genesisHash) || _constants.ALL_GENESIS_HASH;
-        } catch {
-          accountInfo.currentGenesisHash = _constants.ALL_GENESIS_HASH;
-        }
-      } else {
-        accountInfo.currentGenesisHash = accountInfo.allGenesisHash || _constants.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);
       });
     });
   }
@@ -1088,10 +872,10 @@ class KoniExtension {
   async getPrice() {
     return this.#koniState.priceService.getPrice();
   }
-  async setPriceCurrency(_ref35) {
+  async setPriceCurrency(_ref25) {
     let {
       currency
-    } = _ref35;
+    } = _ref25;
     return await this.#koniState.priceService.setPriceCurrency(currency);
   }
   subscribePrice(id, port) {
@@ -1143,138 +927,24 @@ 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 = (0, _keyring.createPair)({
-      toSS58: this.encodeAddress,
-      type: cryptoType
-    }, {
-      publicKey: this.decodeAddress(json.address, true)
-    }, json.meta, (0, _util.isHex)(json.encoded) ? (0, _util.hexToU8a)(json.encoded) : (0, _utilCrypto.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 {
-      (0, _util.u8aToString)((0, _utilCrypto.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(_ref36) {
-    let {
-      genesisHash,
-      isAllowed,
-      name,
-      password,
-      suri: _suri,
-      types
-    } = _ref36;
-    const addressDict = {};
-    let changedAccount = false;
-    const hasMasterPassword = _uiKeyring.keyring.keyring.hasMasterPassword;
-    if (!hasMasterPassword) {
-      if (!password) {
-        throw Error((0, _i18next.t)('The password of each account is needed to set up master password'));
-      } else {
-        _uiKeyring.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 = _uiKeyring.keyring.createFromUri(suri, {}, type).address;
-      addressDict[type] = address;
-      const newAccountName = type === 'ethereum' ? `${name} - EVM` : name;
-      _uiKeyring.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: _constants.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(_ref37) {
-    let {
-      address,
-      lockAfter
-    } = _ref37;
-    _uiKeyring.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 {
@@ -1282,251 +952,50 @@ 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: _constants.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(_ref38) {
-    let {
-      length = SEED_DEFAULT_LENGTH,
-      seed: _seed,
-      types
-    } = _ref38;
-    const seed = _seed || (0, _utilCrypto.mnemonicGenerate)(length);
-    const rs = {
-      seed: seed,
-      addressMap: {}
-    };
-    types === null || types === void 0 ? void 0 : types.forEach(type => {
-      rs.addressMap[type] = _uiKeyring.keyring.createFromUri(getSuri(seed, type), {}, type).address;
-    });
-    return rs;
+  seedCreateV2(request) {
+    return this.#koniState.keyringService.context.mnemonicCreateV2(request);
   }
-  seedValidateV2(_ref39) {
-    let {
-      suri,
-      types
-    } = _ref39;
-    const {
-      phrase
-    } = (0, _utilCrypto.keyExtractSuri)(suri);
-    if ((0, _util.isHex)(phrase)) {
-      (0, _util.assert)((0, _util.isHex)(phrase, 256), (0, _i18next.t)('Invalid seed phrase. Please try again.'));
-    } else {
-      // sadly isHex detects as string, so we need a cast here
-      (0, _util.assert)(SEED_LENGTHS.includes(phrase.split(' ').length), (0, _i18next.t)('Seed phrase needs to contain {{x}} words', {
-        replace: {
-          x: SEED_LENGTHS.join(', ')
-        }
-      }));
-      (0, _util.assert)((0, _utilCrypto.mnemonicValidate)(phrase), (0, _i18next.t)('Invalid seed phrase. Please try again.'));
-    }
-    const rs = {
-      seed: suri,
-      addressMap: {}
-    };
-    types && types.forEach(type => {
-      rs.addressMap[type] = _uiKeyring.keyring.createFromUri(getSuri(suri, type), {}, type).address;
-    });
-    return rs;
+  seedValidateV2(request) {
+    return this.#koniState.keyringService.context.mnemonicValidateV2(request);
   }
-  _checkValidatePrivateKey(_ref40) {
-    let {
-      suri,
-      types
-    } = _ref40;
-    let autoAddPrefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    const {
-      phrase
-    } = (0, _utilCrypto.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 ((0, _util.isHex)(phrase) && (0, _util.isHex)(phrase, 256)) {
-      types && types.forEach(type => {
-        rs.addressMap[type] = _uiKeyring.keyring.createFromUri(getSuri(suri, type), {}, type).address;
-      });
-    } else {
-      rs.autoAddPrefix = false;
-      (0, _util.assert)(false, (0, _i18next.t)('Invalid private key. Please try again.'));
-    }
-    return rs;
+  privateKeyValidateV2(request) {
+    return this.#koniState.keyringService.context.privateKeyValidateV2(request);
   }
-  metamaskPrivateKeyValidateV2(_ref41) {
-    let {
-      suri,
-      types
-    } = _ref41;
-    const isValidSuri = suri.startsWith('0x');
-    if (isValidSuri) {
-      return this._checkValidatePrivateKey({
-        suri,
-        types
-      });
-    } else {
-      return this._checkValidatePrivateKey({
-        suri: `0x${suri}`,
-        types
-      }, true);
-    }
-  }
-  deriveV2(parentAddress, suri, metadata) {
-    const parentPair = _uiKeyring.keyring.getPair(parentAddress);
-    if (parentPair.isLocked) {
-      _uiKeyring.keyring.unlockPair(parentPair.address);
-    }
-    try {
-      return parentPair.derive(suri, metadata);
-    } catch (err) {
-      throw new Error((0, _i18next.t)('"{{suri}}" is not a valid derivation path', {
-        replace: {
-          suri
-        }
-      }));
-    }
+
+  /* JSON */
+
+  parseInfoSingleJson(request) {
+    return this.#koniState.keyringService.context.parseInfoSingleJson(request);
   }
-  derivationCreateV2(_ref42) {
-    let {
-      genesisHash,
-      isAllowed,
-      name,
-      parentAddress,
-      suri
-    } = _ref42;
-    const childPair = this.deriveV2(parentAddress, suri, {
-      genesisHash,
-      name,
-      parentAddress,
-      suri
-    });
-    const address = childPair.address;
-    this._saveCurrentAccountAddress(address, () => {
-      _uiKeyring.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(_ref43) {
-    let {
-      address,
-      file,
-      isAllowed,
-      password,
-      withMasterPassword
-    } = _ref43;
-    const isPasswordValidated = this.validatePassword(file, password);
-    const {
-      promise,
-      resolve
-    } = (0, _utils4.createPromiseHandler)();
-    if (isPasswordValidated) {
-      try {
-        this._saveCurrentAccountAddress(address, () => {
-          var _newAccount$meta, _newAccount$meta2;
-          const newAccount = _uiKeyring.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) !== '') {
-            _uiKeyring.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((0, _i18next.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(_ref44) {
-    let {
-      accountsInfo,
-      file,
-      isAllowed,
-      password
-    } = _ref44;
-    const addressList = accountsInfo.map(acc => acc.address);
-    const isPasswordValidated = this.validatedAccountsPassword(file, password);
-    const {
-      promise,
-      resolve
-    } = (0, _utils4.createPromiseHandler)();
-    if (isPasswordValidated) {
-      try {
-        this._saveCurrentAccountAddress(_constants.ALL_ACCOUNT_KEY, () => {
-          _uiKeyring.keyring.restoreAccounts(file, password);
-          this.#koniState.keyringService.removeNoneHardwareGenesisHash();
-          const successAddressList = addressList.reduce((addressList, address) => {
-            try {
-              const account = _uiKeyring.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((0, _i18next.t)('Wrong password'));
-    }
-  }
-  async batchExportV2(_ref45) {
-    let {
-      addresses,
-      password
-    } = _ref45;
-    try {
-      if (addresses && !addresses.length) {
-        throw new Error((0, _i18next.t)('No accounts found to export'));
-      }
-      return {
-        exportedJson: await _uiKeyring.keyring.backupAccounts(password, addresses)
-      };
-    } catch (e) {
-      const error = e;
-      if (error.message === 'Invalid master password') {
-        throw new Error((0, _i18next.t)('Wrong password'));
-      } else {
-        throw error;
-      }
-    }
+  exportAccountProxyMnemonic(request) {
+    return this.#koniState.keyringService.context.exportAccountProxyMnemonic(request);
   }
   getNftCollection() {
     return this.#koniState.getNftCollection();
@@ -1603,7 +1072,7 @@ class KoniExtension {
       const addresses = _uiKeyring.keyring.getAccounts().map(a => a.address);
 
       // Re-filter
-      cb(histories.filter(item => addresses.some(address => (0, _utils4.isSameAddress)(item.address, address))));
+      cb(histories.filter(item => addresses.some(address => (0, _utils5.isSameAddress)(item.address, address))));
     });
     this.createUnsubscriptionHandle(id, subscription.unsubscribe);
     port.onDisconnect.addListener(() => {
@@ -1612,13 +1081,13 @@ class KoniExtension {
     const addresses = _uiKeyring.keyring.getAccounts().map(a => a.address);
 
     // Re-filter
-    return historySubject.getValue().filter(item => addresses.some(address => (0, _utils4.isSameAddress)(item.address, address)));
+    return historySubject.getValue().filter(item => addresses.some(address => (0, _utils5.isSameAddress)(item.address, address)));
   }
-  subscribeHistoryByChainAndAddress(_ref46, id, port) {
+  subscribeHistoryByChainAndAddress(_ref26, id, port) {
     let {
       address,
       chain
-    } = _ref46;
+    } = _ref26;
     const cb = (0, _subscriptions.createSubscription)(id, port);
     const subscribeHistoriesResponse = this.#koniState.historyService.subscribeHistories(chain, address, cb);
     this.createUnsubscriptionHandle(id, subscribeHistoriesResponse.unsubscribe);
@@ -1669,12 +1138,12 @@ class KoniExtension {
       to,
       tokenSlug,
       transferAll,
+      transferBounceable,
       value
     } = inputData;
     const transferTokenInfo = this.#koniState.chainService.getAssetBySlug(tokenSlug);
     const [errors,,] = (0, _transfer.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;
@@ -1683,8 +1152,8 @@ class KoniExtension {
     let chainType = _KoniTypes.ChainType.SUBSTRATE;
     const transferAmount = {
       value: '0',
-      symbol: (0, _utils3._getAssetSymbol)(transferTokenInfo),
-      decimals: (0, _utils3._getAssetDecimals)(transferTokenInfo)
+      symbol: (0, _utils4._getAssetSymbol)(transferTokenInfo),
+      decimals: (0, _utils4._getAssetDecimals)(transferTokenInfo)
     };
     let transaction;
     const transferTokenAvailable = await this.getAddressTransferableBalance({
@@ -1694,20 +1163,34 @@ class KoniExtension {
       extrinsicType
     });
     try {
-      if ((0, _utilCrypto.isEthereumAddress)(from) && (0, _utilCrypto.isEthereumAddress)(to) && (0, _utils3._isTokenTransferredByEvm)(transferTokenInfo)) {
+      if ((0, _utilCrypto.isEthereumAddress)(from) && (0, _utilCrypto.isEthereumAddress)(to) && (0, _utils4._isTokenTransferredByEvm)(transferTokenInfo)) {
         chainType = _KoniTypes.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 ((0, _utils3._isTokenEvmSmartContract)(transferTokenInfo) || (0, _utils3._isLocalToken)(transferTokenInfo)) {
-          [transaction, transferAmount.value] = await (0, _smartContract.getERC20TransactionObject)((0, _utils3._getContractAddressOfToken)(transferTokenInfo), chainInfo, from, to, txVal, !!transferAll, evmApi);
+        if ((0, _utils4._isTokenEvmSmartContract)(transferTokenInfo) || (0, _utils4._isLocalToken)(transferTokenInfo)) {
+          [transaction, transferAmount.value] = await (0, _smartContract.getERC20TransactionObject)((0, _utils4._getContractAddressOfToken)(transferTokenInfo), chainInfo, from, to, txVal, !!transferAll, evmApi);
         } else {
           [transaction, transferAmount.value] = await (0, _smartContract.getEVMTransactionObject)(chainInfo, from, to, txVal, !!transferAll, evmApi);
         }
-      } else if ((0, _utils3._isMantaZkAsset)(transferTokenInfo)) {
+      } else if ((0, _utils4._isMantaZkAsset)(transferTokenInfo)) {
         transaction = undefined;
         transferAmount.value = '0';
+      } else if ((0, _keyring.isTonAddress)(from) && (0, _keyring.isTonAddress)(to) && (0, _utils4._isTokenTransferredByTon)(transferTokenInfo)) {
+        chainType = _KoniTypes.ChainType.TON;
+        const tonApi = this.#koniState.getTonApi(networkKey);
+        [transaction, transferAmount.value] = await (0, _tonTransfer.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 (0, _token.createTransferExtrinsic)({
@@ -1761,6 +1244,13 @@ class KoniExtension {
       warnings.length && inputTransaction.warnings.push(...warnings);
       errors.length && inputTransaction.errors.push(...errors);
     };
+    const ignoreWarnings = [];
+    if (transferAll) {
+      ignoreWarnings.push(_types2.BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT);
+    }
+    if (transferBounceable) {
+      ignoreWarnings.push(_types2.BasicTxWarningCode.IS_BOUNCEABLE_ADDRESS);
+    }
     return this.#koniState.transactionService.handleTransaction({
       errors,
       warnings,
@@ -1771,7 +1261,7 @@ class KoniExtension {
       transaction,
       data: inputData,
       extrinsicType,
-      ignoreWarnings: transferAll,
+      ignoreWarnings,
       isTransferAll: isTransferNativeToken ? transferAll : false,
       edAsWarning: isTransferNativeToken,
       additionalValidator: additionalValidator
@@ -1784,6 +1274,8 @@ class KoniExtension {
       originNetworkKey,
       to,
       tokenSlug,
+      transferAll,
+      transferBounceable,
       value
     } = inputData;
     const originTokenInfo = this.#koniState.getAssetBySlug(tokenSlug);
@@ -1794,7 +1286,7 @@ class KoniExtension {
       return this.#koniState.transactionService.generateBeforeHandleResponseErrors(errors);
     }
     const chainInfoMap = this.#koniState.getChainInfoMap();
-    const isSnowBridgeEvmTransfer = (0, _utils3._isPureEvmChain)(chainInfoMap[originNetworkKey]) && (0, _xcmParser._isSnowBridgeXcm)(chainInfoMap[originNetworkKey], chainInfoMap[destinationNetworkKey]);
+    const isSnowBridgeEvmTransfer = (0, _utils4._isPureEvmChain)(chainInfoMap[originNetworkKey]) && (0, _xcmParser._isSnowBridgeXcm)(chainInfoMap[originNetworkKey], chainInfoMap[destinationNetworkKey]);
     let additionalValidator;
     let eventsHandler;
     if (fromKeyPair && destinationTokenInfo) {
@@ -1861,6 +1353,13 @@ class KoniExtension {
         });
       };
     }
+    const ignoreWarnings = [];
+    if (transferAll) {
+      ignoreWarnings.push(_types2.BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT);
+    }
+    if (transferBounceable) {
+      ignoreWarnings.push(_types2.BasicTxWarningCode.IS_BOUNCEABLE_ADDRESS);
+    }
     return await this.#koniState.transactionService.handleTransaction({
       url: _constants3.EXTENSION_REQUEST_URL,
       address: from,
@@ -1869,9 +1368,9 @@ class KoniExtension {
       data: inputData,
       extrinsicType: _KoniTypes.ExtrinsicType.TRANSFER_XCM,
       chainType: !isSnowBridgeEvmTransfer ? _KoniTypes.ChainType.SUBSTRATE : _KoniTypes.ChainType.EVM,
-      transferNativeAmount: (0, _utils3._isNativeToken)(originTokenInfo) ? value : '0',
-      ignoreWarnings: inputData.transferAll,
-      isTransferAll: inputData.transferAll,
+      transferNativeAmount: (0, _utils4._isNativeToken)(originTokenInfo) ? value : '0',
+      ignoreWarnings,
+      isTransferAll: transferAll,
       errors,
       additionalValidator: additionalValidator,
       eventsHandler: eventsHandler
@@ -1925,21 +1424,21 @@ class KoniExtension {
   disableChain(networkKey) {
     return this.#koniState.disableChain(networkKey);
   }
-  async enableChain(_ref47) {
+  async enableChain(_ref27) {
     let {
       chainSlug,
       enableTokens
-    } = _ref47;
+    } = _ref27;
     return await this.#koniState.enableChain(chainSlug, enableTokens);
   }
   async reconnectChain(chainSlug) {
     return this.#koniState.chainService.reconnectChain(chainSlug);
   }
-  async validateNetwork(_ref48) {
+  async validateNetwork(_ref28) {
     let {
       existedChainSlug,
       provider
-    } = _ref48;
+    } = _ref28;
     return await this.#koniState.validateCustomChain(provider, existedChainSlug);
   }
   resetDefaultNetwork() {
@@ -1964,10 +1463,10 @@ class KoniExtension {
   }
   async deleteCustomAsset(assetSlug) {
     const assetInfo = this.#koniState.getAssetBySlug(assetSlug);
-    if (assetInfo && (0, _utils3._isCustomAsset)(assetSlug)) {
-      if ((0, _utils3._isAssetSmartContractNft)(assetInfo)) {
+    if (assetInfo && (0, _utils4._isCustomAsset)(assetSlug)) {
+      if ((0, _utils4._isAssetSmartContractNft)(assetInfo)) {
         // check if deleting a smart contract NFT
-        await this.#koniState.deleteNftCollection(assetInfo.originChain, (0, _utils3._getContractAddressOfToken)(assetInfo));
+        await this.#koniState.deleteNftCollection(assetInfo.originChain, (0, _utils4._getContractAddressOfToken)(assetInfo));
       }
       this.#koniState.deleteCustomAssets([assetSlug]);
       return true;
@@ -1977,13 +1476,13 @@ class KoniExtension {
   async validateCustomAsset(data) {
     return await this.#koniState.validateCustomAsset(data);
   }
-  async getAddressTransferableBalance(_ref49) {
+  async getAddressTransferableBalance(_ref29) {
     let {
       address,
       extrinsicType,
       networkKey,
       token
-    } = _ref49;
+    } = _ref29;
     if (token && _constants2._MANTA_ZK_CHAIN_GROUP.includes(networkKey)) {
       const tokenInfo = this.#koniState.chainService.getAssetBySlug(token);
       if (tokenInfo.symbol.startsWith(_constants2._ZK_ASSET_PREFIX)) {
@@ -1992,16 +1491,16 @@ class KoniExtension {
     }
     return await this.#koniState.balanceService.getTransferableBalance(address, networkKey, token, extrinsicType);
   }
-  async getMaxTransferable(_ref50) {
+  async getMaxTransferable(_ref30) {
     let {
       address,
       destChain,
       isXcmTransfer,
       networkKey,
       token
-    } = _ref50;
+    } = _ref30;
     const tokenInfo = token ? this.#koniState.chainService.getAssetBySlug(token) : this.#koniState.chainService.getNativeTokenInfo(networkKey);
-    if (!(0, _utils3._isNativeToken)(tokenInfo)) {
+    if (!(0, _utils4._isNativeToken)(tokenInfo)) {
       return await this.getAddressTransferableBalance({
         extrinsicType: _KoniTypes.ExtrinsicType.TRANSFER_TOKEN,
         address,
@@ -2017,7 +1516,7 @@ class KoniExtension {
         maxTransferable = await this.getNativeTokenMaxTransferable(tokenInfo, networkKey, address);
       }
       return {
-        value: maxTransferable.gt(_utils4.BN_ZERO) ? maxTransferable.toFixed(0) || '0' : '0',
+        value: maxTransferable.gt(_utils5.BN_ZERO) ? maxTransferable.toFixed(0) || '0' : '0',
         decimals: tokenInfo.decimals,
         symbol: tokenInfo.symbol
       };
@@ -2045,7 +1544,7 @@ class KoniExtension {
   }
   async getNativeTokenMaxTransferable(tokenInfo, networkKey, address) {
     const chainInfo = this.#koniState.chainService.getChainInfoByKey(networkKey);
-    const api = (0, _utils3._isChainEvmCompatible)(chainInfo) && (0, _utils3._isTokenTransferredByEvm)(tokenInfo) ? this.#koniState.chainService.getEvmApi(networkKey) : this.#koniState.chainService.getSubstrateApi(networkKey);
+    const api = (0, _utils4._isChainEvmCompatible)(chainInfo) && (0, _utils4._isTokenTransferredByEvm)(tokenInfo) ? this.#koniState.chainService.getEvmApi(networkKey) : (0, _utils4._isChainTonCompatible)(chainInfo) && (0, _utils4._isTokenTransferredByTon)(tokenInfo) ? this.#koniState.chainService.getTonApi(networkKey) : this.#koniState.chainService.getSubstrateApi(networkKey);
     const [mockTxFee, {
       value
     }] = await Promise.all([(0, _token.getTransferMockTxFee)(address, chainInfo, tokenInfo, api), this.getAddressTransferableBalance({
@@ -2057,13 +1556,13 @@ class KoniExtension {
     const bnMaxTransferable = new _bignumber.default(value);
     return bnMaxTransferable.minus(mockTxFee);
   }
-  async subscribeAddressTransferableBalance(_ref51, id, port) {
+  async subscribeAddressTransferableBalance(_ref31, id, port) {
     let {
       address,
       extrinsicType,
       networkKey,
       token
-    } = _ref51;
+    } = _ref31;
     const cb = (0, _subscriptions.createSubscription)(id, port);
     const convertData = data => {
       return {
@@ -2114,11 +1613,11 @@ class KoniExtension {
       isSendingSelf
     };
   }
-  async enableChains(_ref52) {
+  async enableChains(_ref32) {
     let {
       chainSlugs,
       enableTokens
-    } = _ref52;
+    } = _ref32;
     try {
       await Promise.all(chainSlugs.map(chainSlug => this.enableChain({
         chainSlug,
@@ -2129,277 +1628,21 @@ class KoniExtension {
     }
     return true;
   }
-  getAccountMeta(_ref53) {
-    let {
-      address
-    } = _ref53;
-    const pair = _uiKeyring.keyring.getPair(address);
-    (0, _util.assert)(pair, (0, _i18next.t)('Unable to find account'));
-    return {
-      meta: pair.meta
-    };
-  }
-  accountsTie2(_ref54) {
-    let {
-      address,
-      genesisHash
-    } = _ref54;
-    return this.#koniState.setAccountTie(address, genesisHash);
-  }
-  async accountsCreateExternalV2(_ref55) {
-    let {
-      address,
-      genesisHash,
-      isAllowed,
-      isEthereum,
-      isReadOnly,
-      name
-    } = _ref55;
-    try {
-      let result;
-      try {
-        const exists = _uiKeyring.keyring.getPair(address);
-        if (exists) {
-          if (exists.type === (isEthereum ? 'ethereum' : 'sr25519')) {
-            return [{
-              code: _KoniTypes.AccountExternalErrorCode.INVALID_ADDRESS,
-              message: (0, _i18next.t)('Account exists')
-            }];
-          }
-        }
-      } catch (e) {}
-      if (isEthereum) {
-        const chainInfoMap = this.#koniState.getChainInfoMap();
-        let _gen = '';
-        if (genesisHash) {
-          for (const network of Object.values(chainInfoMap)) {
-            if ((0, _utils3._getEvmChainId)(network) === parseInt(genesisHash)) {
-              // TODO: pure EVM chains do not have genesisHash
-              _gen = (0, _utils3._getSubstrateGenesisHash)(network);
-            }
-          }
-        }
-        result = _uiKeyring.keyring.keyring.addFromAddress(address, {
-          name,
-          isExternal: true,
-          isReadOnly,
-          genesisHash: _gen
-        }, null, 'ethereum');
-        _uiKeyring.keyring.saveAccount(result);
-      } else {
-        result = _uiKeyring.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: _KoniTypes.AccountExternalErrorCode.KEYRING_ERROR,
-        message: e.message
-      }];
-    }
+  async accountsCreateExternalV2(request) {
+    return this.#koniState.keyringService.context.accountsCreateExternalV2(request);
   }
-  async accountsCreateHardwareV2(_ref56) {
-    let {
-      accountIndex,
-      address,
-      addressOffset,
-      genesisHash,
-      hardwareType,
-      isAllowed,
-      name,
-      originGenesisHash
-    } = _ref56;
-    const key = _uiKeyring.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 accountsCreateHardwareV2(request) {
+    return this.#koniState.keyringService.context.accountsCreateHardwareV2(request);
   }
-  async accountsCreateHardwareMultiple(_ref57) {
-    let {
-      accounts
-    } = _ref57;
-    const addresses = [];
-    if (!accounts.length) {
-      throw new Error((0, _i18next.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 = _uiKeyring.keyring.keyring.addFromAddress(address, {
-          ...baseMeta,
-          isExternal: true,
-          isHardware: true
-        }, null, 'ethereum');
-        _uiKeyring.keyring.saveAccount(result);
-        slugMap.ethereum = 'ethereum';
-      } else {
-        result = _uiKeyring.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: _constants.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 accountsCreateHardwareMultiple(request) {
+    return this.#koniState.keyringService.context.accountsCreateHardwareMultiple(request);
   }
-  async accountsCreateWithSecret(_ref58) {
-    let {
-      isAllow,
-      isEthereum,
-      name,
-      publicKey,
-      secretKey
-    } = _ref58;
-    try {
-      let keyringPair = null;
-      if (isEthereum) {
-        const _secret = (0, _util.hexStripPrefix)(secretKey);
-        if (_secret.length === 64) {
-          const suri = `0x${_secret}`;
-          const {
-            phrase
-          } = (0, _utilCrypto.keyExtractSuri)(suri);
-          if ((0, _util.isHex)(phrase) && (0, _util.isHex)(phrase, 256)) {
-            const type = 'ethereum';
-            keyringPair = _uiKeyring.keyring.addUri(getSuri(suri, type), {
-              name: name
-            }, type).pair;
-          }
-        }
-      } else {
-        keyringPair = _uiKeyring.keyring.keyring.addFromPair({
-          publicKey: (0, _util.hexToU8a)(publicKey),
-          secretKey: (0, _util.hexToU8a)(secretKey)
-        }, {
-          name
-        });
-        _uiKeyring.keyring.addPair(keyringPair, true);
-      }
-      if (!keyringPair) {
-        return {
-          success: false,
-          errors: [{
-            code: _KoniTypes.AccountExternalErrorCode.KEYRING_ERROR,
-            message: (0, _i18next.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: _KoniTypes.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
@@ -2449,9 +1692,21 @@ class KoniExtension {
     });
     return this.#koniState.getConfirmationsQueueSubject().getValue();
   }
+  subscribeConfirmationsTon(id, port) {
+    const cb = (0, _subscriptions.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
 
@@ -2463,7 +1718,7 @@ class KoniExtension {
           continue;
         }
         const networkInfo = chainInfoMap[n];
-        if ((0, _utils3._isChainEvmCompatible)(networkInfo)) {
+        if ((0, _utils4._isChainEvmCompatible)(networkInfo)) {
           return networkInfo;
         }
       }
@@ -2474,7 +1729,7 @@ class KoniExtension {
         continue;
       }
       const networkInfo = chainInfoMap[n];
-      if ((0, _utils3._getEvmChainId)(networkInfo) === chainId) {
+      if ((0, _utils4._getEvmChainId)(networkInfo) === chainId) {
         return networkInfo;
       }
     }
@@ -2483,30 +1738,30 @@ class KoniExtension {
 
   // Parse transaction
 
-  parseSubstrateTransaction(_ref59) {
+  parseSubstrateTransaction(_ref33) {
     let {
       data,
       networkKey
-    } = _ref59;
+    } = _ref33;
     const apiProps = this.#koniState.getSubstrateApi(networkKey);
     const apiPromise = apiProps.api;
     return (0, _parseTransaction.parseSubstrateTransaction)(data, apiPromise);
   }
-  async parseEVMRLP(_ref60) {
+  async parseEVMRLP(_ref34) {
     let {
       data
-    } = _ref60;
+    } = _ref34;
     return await (0, _parseTransaction2.parseEvmRlp)(data, this.#koniState.getChainInfoMap(), this.#koniState.getEvmApiMap());
   }
 
   // Sign
 
-  qrSignSubstrate(_ref61) {
+  qrSignSubstrate(_ref35) {
     let {
       address,
       data,
       networkKey
-    } = _ref61;
+    } = _ref35;
     const pair = _uiKeyring.keyring.getPair(address);
     (0, _util.assert)(pair, (0, _i18next.t)('Unable to find account'));
     if (pair.isLocked) {
@@ -2516,20 +1771,20 @@ class KoniExtension {
       withType: true
     })));
     const network = this.#koniState.getChainInfo(networkKey);
-    if ((0, _utils3._isChainEvmCompatible)(network)) {
+    if ((0, _utils4._isChainEvmCompatible)(network)) {
       signed = signed.substring(2);
     }
     return {
       signature: signed
     };
   }
-  async qrSignEVM(_ref62) {
+  async qrSignEVM(_ref36) {
     let {
       address,
       chainId,
       message,
       type
-    } = _ref62;
+    } = _ref36;
     let signed;
     const network = this.getNetworkJsonByChainId(chainId);
     if (!network) {
@@ -2549,10 +1804,10 @@ class KoniExtension {
       } else if ((0, _util.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 = (0, _utils4.createTransactionFromRLP)(message);
+      const tx = (0, _utils5.createTransactionFromRLP)(message);
       if (!tx) {
         throw new Error((0, _i18next.t)('Failed to decode data. Please use a valid QR code'));
       }
@@ -2566,8 +1821,8 @@ class KoniExtension {
       };
       const common = _common.Common.custom({
         name: network.name,
-        networkId: (0, _utils3._getEvmChainId)(network),
-        chainId: (0, _utils3._getEvmChainId)(network)
+        networkId: (0, _utils4._getEvmChainId)(network),
+        chainId: (0, _utils4._getEvmChainId)(network)
       }, {
         hardfork: 'petersburg'
       });
@@ -2576,8 +1831,8 @@ class KoniExtension {
       const transaction = new _tx.LegacyTransaction(txObject, {
         common
       });
-      const signedTranaction = _tx.LegacyTransaction.fromSerializedTx((0, _util.hexToU8a)(pair.evmSigner.signTransaction(transaction)));
-      signed = (0, _utils4.signatureToHex)({
+      const signedTranaction = _tx.LegacyTransaction.fromSerializedTx((0, _util.hexToU8a)(pair.evm.signTransaction(transaction)));
+      signed = (0, _utils5.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)) || '',
         v: ((_signedTranaction$v = signedTranaction.v) === null || _signedTranaction$v === void 0 ? void 0 : _signedTranaction$v.toString(16)) || ''
@@ -2613,11 +1868,11 @@ class KoniExtension {
     });
     return this.#koniState.getNominatorMetadata();
   }
-  async getBondingOptions(_ref63) {
+  async getBondingOptions(_ref37) {
     let {
       chain,
       type
-    } = _ref63;
+    } = _ref37;
     const apiProps = this.#koniState.getSubstrateApi(chain);
     const chainInfo = this.#koniState.getChainInfo(chain);
     const chainStakingMetadata = await this.#koniState.getStakingMetadataByChain(chain, type);
@@ -2626,7 +1881,7 @@ class KoniExtension {
     }
     const {
       decimals
-    } = (0, _utils3._getChainNativeTokenBasicInfo)(chainInfo);
+    } = (0, _utils4._getChainNativeTokenBasicInfo)(chainInfo);
     return await (0, _bonding.getValidatorsInfo)(chain, apiProps, decimals, chainStakingMetadata);
   }
   async getNominationPoolOptions(chain) {
@@ -2649,7 +1904,7 @@ class KoniExtension {
           chainName: chainInfo.name
         }
       });
-      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.CAN_NOT_GET_METADATA, errMessage)]);
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types2.StakingTxErrorType.CAN_NOT_GET_METADATA, errMessage)]);
     }
     const bondingValidation = (0, _bonding.validateBondingCondition)(chainInfo, amount, selectedValidators, address, chainStakingMetadata, nominatorMetadata);
     if (!amount || !selectedValidators || bondingValidation.length > 0) {
@@ -2677,7 +1932,7 @@ class KoniExtension {
     } = inputData;
     const chainStakingMetadata = await this.#koniState.getStakingMetadataByChain(chain, _KoniTypes.StakingType.NOMINATED);
     if (!chainStakingMetadata || !nominatorMetadata) {
-      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)]);
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types2.BasicTxErrorType.INTERNAL_ERROR)]);
     }
     const unbondingValidation = (0, _bonding.validateUnbondingCondition)(nominatorMetadata, amount, chain, chainStakingMetadata, validatorAddress);
     if (!amount || unbondingValidation.length > 0) {
@@ -2702,7 +1957,7 @@ class KoniExtension {
     } = inputData;
     const poolHandler = this.#koniState.earningService.getPoolHandler(slug);
     if (!address || !poolHandler) {
-      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS)]);
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types2.BasicTxErrorType.INVALID_PARAMS)]);
     }
     const chain = poolHandler.chain;
     const stakingType = poolHandler.type === _types2.YieldPoolType.NOMINATION_POOL ? _KoniTypes.StakingType.POOLED : _KoniTypes.StakingType.NOMINATED;
@@ -2726,7 +1981,7 @@ class KoniExtension {
     } = inputData;
     const chain = (_this$koniState$earni = this.#koniState.earningService.getPoolHandler(slug)) === null || _this$koniState$earni === void 0 ? void 0 : _this$koniState$earni.chain;
     if (!chain || !selectedUnstaking) {
-      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS)]);
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types2.BasicTxErrorType.INVALID_PARAMS)]);
     }
     const substrateApi = this.#koniState.getSubstrateApi(chain);
     // @ts-ignore
@@ -2756,7 +2011,7 @@ class KoniExtension {
           chainName: chainInfo.name
         }
       });
-      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.CAN_NOT_GET_METADATA, errMessage)]);
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types2.StakingTxErrorType.CAN_NOT_GET_METADATA, errMessage)]);
     }
     const bondingValidation = (0, _relayChain.validatePoolBondingCondition)(chainInfo, amount, selectedPool, address, chainStakingMetadata, nominatorMetadata);
     if (!amount || bondingValidation.length > 0) {
@@ -2788,7 +2043,7 @@ class KoniExtension {
           chainName: chainInfo === null || chainInfo === void 0 ? void 0 : chainInfo.name
         }
       });
-      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.CAN_NOT_GET_METADATA, errMessage)]);
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types2.StakingTxErrorType.CAN_NOT_GET_METADATA, errMessage)]);
     }
     const unbondingValidation = (0, _relayChain.validateRelayUnbondingCondition)(amount, chainStakingMetadata, nominatorMetadata);
     if (!amount || unbondingValidation.length > 0) {
@@ -2807,12 +2062,12 @@ class KoniExtension {
   }
 
   // EVM Transaction
-  async parseContractInput(_ref64) {
+  async parseContractInput(_ref38) {
     let {
       chainId,
       contract,
       data
-    } = _ref64;
+    } = _ref38;
     const network = this.getNetworkJsonByChainId(chainId);
     return await (0, _parseTransaction2.parseContractInput)(data, contract, network);
   }
@@ -2825,13 +2080,13 @@ class KoniExtension {
       networkKey
     } = inputData;
     if (!address) {
-      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS)]);
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types2.BasicTxErrorType.INVALID_PARAMS)]);
     }
     const dotSamaApi = this.#koniState.getSubstrateApi(networkKey);
     const chainInfo = this.#koniState.getChainInfo(networkKey);
     const {
       decimals
-    } = (0, _utils3._getChainNativeTokenBasicInfo)(chainInfo);
+    } = (0, _utils4._getChainNativeTokenBasicInfo)(chainInfo);
     const parsedAccountMinimum = parseFloat(accountMinimum) * 10 ** decimals;
     const extrinsic = await (0, _paraChain.getTuringCompoundExtrinsic)(dotSamaApi, address, collatorAddress, parsedAccountMinimum.toString(), bondedAmount);
     return await this.#koniState.transactionService.handleTransaction({
@@ -2872,8 +2127,7 @@ class KoniExtension {
 
   keyringStateSubscribe(id, port) {
     const cb = (0, _subscriptions.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);
@@ -2883,48 +2137,14 @@ class KoniExtension {
 
   // Change master password
 
-  keyringChangeMasterPassword(_ref65) {
-    let {
-      createNew,
-      newPassword,
-      oldPassword
-    } = _ref65;
-    try {
-      // Remove isMasterPassword meta if createNew
-      if (createNew && !_uiKeyring.keyring.keyring.hasMasterPassword) {
-        const pairs = _uiKeyring.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);
-            _uiKeyring.keyring.saveAccountMeta(pair, pair.meta);
-          }
-        }
+  keyringChangeMasterPassword(request) {
+    const createNew = request.createNew;
+    const callback = () => {
+      if (this.#alwaysLock && !createNew) {
+        this.keyringLock();
       }
-      _uiKeyring.keyring.changeMasterPassword(newPassword, oldPassword);
-    } catch (e) {
-      console.error(e);
-      return {
-        errors: [(0, _i18next.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
@@ -2938,33 +2158,19 @@ class KoniExtension {
       }
     }
   }
-  keyringMigrateMasterPassword(_ref66) {
-    let {
-      address,
-      password
-    } = _ref66;
-    try {
-      _uiKeyring.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
 
-  keyringUnlock(_ref67) {
+  keyringUnlock(_ref39) {
     let {
       password
-    } = _ref67;
+    } = _ref39;
     try {
       _uiKeyring.keyring.unlockKeyring(password);
       // this.#koniState.initMantaPay(password)
@@ -2995,11 +2201,11 @@ class KoniExtension {
 
   // Export mnemonic
 
-  keyringExportMnemonic(_ref68) {
+  keyringExportMnemonic(_ref40) {
     let {
       address,
       password
-    } = _ref68;
+    } = _ref40;
     const pair = _uiKeyring.keyring.getPair(address);
     const result = pair.exportMnemonic(password);
     return {
@@ -3009,10 +2215,10 @@ class KoniExtension {
 
   // Reset wallet
 
-  async resetWallet(_ref69) {
+  async resetWallet(_ref41) {
     let {
       resetAll
-    } = _ref69;
+    } = _ref41;
     try {
       await this.#koniState.resetWallet(resetAll);
       return {
@@ -3028,10 +2234,10 @@ class KoniExtension {
   }
 
   /// Signing substrate request
-  async signingApprovePasswordV2(_ref70) {
+  async signingApprovePasswordV2(_ref42) {
     let {
       id
-    } = _ref70;
+    } = _ref42;
     const queued = this.#koniState.getSignRequest(id);
     (0, _util.assert)(queued, (0, _i18next.t)('Unable to proceed. Please try again'));
     const {
@@ -3039,7 +2245,7 @@ class KoniExtension {
       request,
       resolve
     } = queued;
-    const pair = _uiKeyring.keyring.getPair(queued.account.address);
+    const pair = _uiKeyring.keyring.getPair(queued.address);
 
     // unlike queued.account.address the following
     // address is encoded with the default prefix
@@ -3076,8 +2282,8 @@ class KoniExtension {
         metadata = await this.#koniState.chainService.getMetadataByHash(payload.genesisHash);
         if (metadata) {
           var _chainInfo$substrateI, _chainInfo$substrateI2, _chainInfo$substrateI3, _chainInfo$substrateI4;
-          registry = new _types3.TypeRegistry();
-          const _metadata = new _types3.Metadata(registry, metadata.hexValue);
+          registry = new _types4.TypeRegistry();
+          const _metadata = new _types4.Metadata(registry, metadata.hexValue);
           registry.register(metadata.types);
           registry.setChainProperties(registry.createType('ChainProperties', {
             ss58Format: (_chainInfo$substrateI = chainInfo === null || chainInfo === void 0 ? void 0 : (_chainInfo$substrateI2 = chainInfo.substrateInfo) === null || _chainInfo$substrateI2 === void 0 ? void 0 : _chainInfo$substrateI2.addressPrefix) !== null && _chainInfo$substrateI !== void 0 ? _chainInfo$substrateI : 42,
@@ -3087,7 +2293,7 @@ class KoniExtension {
           registry.setMetadata(_metadata, payload.signedExtensions, metadata.userExtensions);
         } else {
           // we have no metadata, create a new registry
-          registry = new _types3.TypeRegistry();
+          registry = new _types4.TypeRegistry();
           registry.setSignedExtensions(payload.signedExtensions);
         }
       }
@@ -3113,7 +2319,7 @@ class KoniExtension {
       }
     } else {
       // for non-payload, just create a registry to use
-      registry = new _types3.TypeRegistry();
+      registry = new _types4.TypeRegistry();
     }
     const result = request.sign(registry, pair);
     resolve({
@@ -3129,167 +2335,24 @@ class KoniExtension {
 
   /// Derive account
 
-  derivationCreateMultiple(_ref71) {
-    let {
-      isAllowed,
-      items,
-      parentAddress
-    } = _ref71;
-    const parentPair = _uiKeyring.keyring.getPair(parentAddress);
-    const isEvm = parentPair.type === 'ethereum';
-    if (parentPair.isLocked) {
-      _uiKeyring.keyring.unlockPair(parentPair.address);
-    }
-    const createChild = _ref72 => {
-      let {
-        name,
-        suri
-      } = _ref72;
-      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((0, _i18next.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;
-        _uiKeyring.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: _constants.ALL_ACCOUNT_KEY,
-        currentGenesisHash: null
-      });
-    }
-    return true;
+  derivationCreateMultiple(request) {
+    return this.#koniState.keyringService.context.derivationCreateMultiple(request);
   }
-  derivationCreateV3(_ref73) {
-    let {
-      address: parentAddress
-    } = _ref73;
-    const parentPair = _uiKeyring.keyring.getPair(parentAddress);
-    const isEvm = parentPair.type === 'ethereum';
-    if (parentPair.isLocked) {
-      _uiKeyring.keyring.unlockPair(parentPair.address);
-    }
-    const pairs = _uiKeyring.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, () => {
-      _uiKeyring.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(_ref74) {
-    let {
-      parentAddress,
-      suri
-    } = _ref74;
-    const parentPair = _uiKeyring.keyring.getPair(parentAddress);
-    const isEvm = parentPair.type === 'ethereum';
-    if (parentPair.isLocked) {
-      _uiKeyring.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((0, _i18next.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(_ref75) {
-    let {
-      limit,
-      page,
-      parentAddress
-    } = _ref75;
-    const parentPair = _uiKeyring.keyring.getPair(parentAddress);
-    const isEvm = parentPair.type === 'ethereum';
-    if (parentPair.isLocked) {
-      _uiKeyring.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 -------------------------------------------------
@@ -3380,10 +2443,10 @@ class KoniExtension {
   getSupportedSmartContractTypes() {
     return this.#koniState.getSupportedSmartContractTypes();
   }
-  getTransaction(_ref76) {
+  getTransaction(_ref43) {
     let {
       id
-    } = _ref76;
+    } = _ref43;
     const {
       transaction,
       ...transactionResult
@@ -3393,8 +2456,8 @@ class KoniExtension {
   subscribeTransactions(id, port) {
     const cb = (0, _subscriptions.createSubscription)(id, port);
     function convertRs(rs) {
-      return Object.fromEntries(Object.entries(rs).map(_ref77 => {
-        let [key, value] = _ref77;
+      return Object.fromEntries(Object.entries(rs).map(_ref44 => {
+        let [key, value] = _ref44;
         const {
           additionalValidator,
           eventsHandler,
@@ -3426,10 +2489,10 @@ class KoniExtension {
     });
     return notificationSubject.value;
   }
-  async reloadCron(_ref78) {
+  async reloadCron(_ref45) {
     let {
       data
-    } = _ref78;
+    } = _ref45;
     if (data === 'nft') {
       return await this.#koniState.reloadNft();
     } else if (data === 'staking') {
@@ -3473,20 +2536,20 @@ class KoniExtension {
 
   // Phishing detect
 
-  async passPhishingPage(_ref79) {
+  async passPhishingPage(_ref46) {
     let {
       url
-    } = _ref79;
+    } = _ref46;
     return await this.#koniState.approvePassPhishingPage(url);
   }
 
   /// Wallet connect
 
   // Connect
-  async connectWalletConnect(_ref80) {
+  async connectWalletConnect(_ref47) {
     let {
       uri
-    } = _ref80;
+    } = _ref47;
     await this.#koniState.walletConnectService.connect(uri);
     return true;
   }
@@ -3499,11 +2562,11 @@ class KoniExtension {
     });
     return this.#koniState.requestService.allConnectWCRequests;
   }
-  async approveWalletConnectSession(_ref81) {
+  async approveWalletConnectSession(_ref48) {
     let {
       accounts: selectedAccounts,
       id
-    } = _ref81;
+    } = _ref48;
     const request = this.#koniState.requestService.getConnectWCRequest(id);
     if ((0, _helpers2.isProposalExpired)(request.request.params)) {
       throw new Error('The proposal has been expired');
@@ -3515,22 +2578,22 @@ class KoniExtension {
     const availableNamespaces = {};
     const namespaces = {};
     const chainInfoMap = this.#koniState.getChainInfoMap();
-    Object.entries(requiredNamespaces).forEach(_ref82 => {
-      let [key, namespace] = _ref82;
+    Object.entries(requiredNamespaces).forEach(_ref49 => {
+      let [key, namespace] = _ref49;
       if ((0, _helpers2.isSupportWalletConnectNamespace)(key)) {
         if (namespace.chains) {
           const unSupportChains = namespace.chains.filter(chain => !(0, _helpers2.isSupportWalletConnectChain)(chain, chainInfoMap));
           if (unSupportChains.length) {
-            throw new Error((0, _utils5.getSdkError)('UNSUPPORTED_CHAINS').message + ' ' + unSupportChains.toString());
+            throw new Error((0, _utils6.getSdkError)('UNSUPPORTED_CHAINS').message + ' ' + unSupportChains.toString());
           }
           availableNamespaces[key] = namespace;
         }
       } else {
-        throw new Error((0, _utils5.getSdkError)('UNSUPPORTED_NAMESPACE_KEY').message + ' ' + key);
+        throw new Error((0, _utils6.getSdkError)('UNSUPPORTED_NAMESPACE_KEY').message + ' ' + key);
       }
     });
-    Object.entries(optionalNamespaces).forEach(_ref83 => {
-      let [key, namespace] = _ref83;
+    Object.entries(optionalNamespaces).forEach(_ref50 => {
+      let [key, namespace] = _ref50;
       if ((0, _helpers2.isSupportWalletConnectNamespace)(key)) {
         if (namespace.chains) {
           const supportChains = namespace.chains.filter(chain => (0, _helpers2.isSupportWalletConnectChain)(chain, chainInfoMap)) || [];
@@ -3554,11 +2617,11 @@ class KoniExtension {
         }
       }
     });
-    Object.entries(availableNamespaces).forEach(_ref84 => {
-      let [key, namespace] = _ref84;
+    Object.entries(availableNamespaces).forEach(_ref51 => {
+      let [key, namespace] = _ref51;
       if (namespace.chains) {
         const accounts = [];
-        const chains = (0, _utils4.uniqueStringArray)(namespace.chains);
+        const chains = (0, _utils5.uniqueStringArray)(namespace.chains);
         chains.forEach(chain => {
           accounts.push(...selectedAccounts.filter(address => (0, _utilCrypto.isEthereumAddress)(address) === (key === _constants5.WALLET_CONNECT_EIP155_NAMESPACE)).map(address => `${chain}:${address}`));
         });
@@ -3579,10 +2642,10 @@ class KoniExtension {
     request.resolve();
     return true;
   }
-  async rejectWalletConnectSession(_ref85) {
+  async rejectWalletConnectSession(_ref52) {
     let {
       id
-    } = _ref85;
+    } = _ref52;
     const request = this.#koniState.requestService.getConnectWCRequest(id);
     const wcId = request.request.id;
     if ((0, _helpers2.isProposalExpired)(request.request.params)) {
@@ -3604,10 +2667,10 @@ class KoniExtension {
     });
     return this.#koniState.walletConnectService.sessions;
   }
-  async disconnectWalletConnectSession(_ref86) {
+  async disconnectWalletConnectSession(_ref53) {
     let {
       topic
-    } = _ref86;
+    } = _ref53;
     await this.#koniState.walletConnectService.disconnect(topic);
     return true;
   }
@@ -3620,18 +2683,18 @@ class KoniExtension {
     });
     return this.#koniState.requestService.allNotSupportWCRequests;
   }
-  approveWalletConnectNotSupport(_ref87) {
+  approveWalletConnectNotSupport(_ref54) {
     let {
       id
-    } = _ref87;
+    } = _ref54;
     const request = this.#koniState.requestService.getNotSupportWCRequest(id);
     request.resolve();
     return true;
   }
-  rejectWalletConnectNotSupport(_ref88) {
+  rejectWalletConnectNotSupport(_ref55) {
     let {
       id
-    } = _ref88;
+    } = _ref55;
     const request = this.#koniState.requestService.getNotSupportWCRequest(id);
     request.reject(new Error('USER_REJECTED'));
     return true;
@@ -3639,11 +2702,11 @@ class KoniExtension {
 
   /// Manta
 
-  async enableMantaPay(_ref89) {
+  async enableMantaPay(_ref56) {
     let {
       address,
       password
-    } = _ref89;
+    } = _ref56;
     // always takes the current account
     function timeout() {
       return new Promise(resolve => setTimeout(resolve, 1500));
@@ -3665,7 +2728,7 @@ 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());
@@ -3700,11 +2763,11 @@ class KoniExtension {
   }
   async initSyncMantaPay(address) {
     var _this$koniState$chain3, _this$koniState$chain4, _this$koniState$chain5, _this$koniState$chain6;
-    if ((_this$koniState$chain3 = this.#koniState.chainService) !== null && _this$koniState$chain3 !== void 0 && (_this$koniState$chain4 = _this$koniState$chain3.mantaPay) !== null && _this$koniState$chain4 !== void 0 && _this$koniState$chain4.getSyncState().isSyncing || !_utils4.MODULE_SUPPORT.MANTA_ZK) {
+    if ((_this$koniState$chain3 = this.#koniState.chainService) !== null && _this$koniState$chain3 !== void 0 && (_this$koniState$chain4 = _this$koniState$chain3.mantaPay) !== null && _this$koniState$chain4 !== void 0 && _this$koniState$chain4.getSyncState().isSyncing || !_utils5.MODULE_SUPPORT.MANTA_ZK) {
       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());
@@ -3733,6 +2796,22 @@ class KoniExtension {
   async disableMantaPay(address) {
     return this.#koniState.disableMantaPay(address);
   }
+  async isTonBounceableAddress(_ref57) {
+    let {
+      address,
+      chain
+    } = _ref57;
+    try {
+      const tonApi = this.#koniState.getTonApi(chain);
+      const state = await tonApi.getAccountState(address);
+      const isActive = state === 'active';
+      const isBounceable = (0, _utils3.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 = (0, _subscriptions.createSubscription)(id, port);
     const mantaPayConfigSubscription = this.#koniState.subscribeMantaPayConfig().subscribe({
@@ -3767,10 +2846,10 @@ class KoniExtension {
 
   /* Metadata */
 
-  async findRawMetadata(_ref90) {
+  async findRawMetadata(_ref58) {
     let {
       genesisHash
-    } = _ref90;
+    } = _ref58;
     const {
       metadata,
       specVersion,
@@ -3784,20 +2863,20 @@ class KoniExtension {
       userExtensions
     };
   }
-  async calculateMetadataHash(_ref91) {
+  async calculateMetadataHash(_ref59) {
     let {
       chain
-    } = _ref91;
+    } = _ref59;
     const hash = await this.#koniState.calculateMetadataHash(chain);
     return {
       metadataHash: hash || ''
     };
   }
-  async shortenMetadata(_ref92) {
+  async shortenMetadata(_ref60) {
     let {
       chain,
       txBlob
-    } = _ref92;
+    } = _ref60;
     const shorten = await this.#koniState.shortenMetadata(chain, txBlob);
     return {
       txMetadata: shorten || ''
@@ -3817,11 +2896,11 @@ 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) {
@@ -3853,7 +2932,7 @@ class KoniExtension {
       address
     } = data;
     if (!data) {
-      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)]);
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types2.BasicTxErrorType.INTERNAL_ERROR)]);
     }
     const isLastStep = inputData.currentStep + 1 === path.steps.length;
     const yieldValidation = await this.#koniState.earningService.validateYieldJoin({
@@ -3988,7 +3067,7 @@ class KoniExtension {
     } = params;
     const poolHandler = this.#koniState.earningService.getPoolHandler(slug);
     if (!poolHandler) {
-      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS)]);
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types2.BasicTxErrorType.INVALID_PARAMS)]);
     }
     const extrinsic = await this.#koniState.earningService.handleYieldWithdraw(params);
     return await this.#koniState.transactionService.handleTransaction({
@@ -4008,7 +3087,7 @@ class KoniExtension {
     } = params;
     const poolHandler = this.#koniState.earningService.getPoolHandler(slug);
     if (!poolHandler || !selectedUnstaking) {
-      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS)]);
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types2.BasicTxErrorType.INVALID_PARAMS)]);
     }
     const chain = poolHandler.chain;
     const extrinsic = await this.#koniState.earningService.handleYieldCancelUnstake(params);
@@ -4028,7 +3107,7 @@ class KoniExtension {
     } = params;
     const poolHandler = this.#koniState.earningService.getPoolHandler(slug);
     if (!address || !poolHandler) {
-      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS)]);
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types2.BasicTxErrorType.INVALID_PARAMS)]);
     }
     const extrinsic = await this.#koniState.earningService.handleYieldClaimReward(params);
     return await this.#koniState.transactionService.handleTransaction({
@@ -4043,18 +3122,18 @@ class KoniExtension {
 
   /* Campaign */
 
-  unlockDotCheckCanMint(_ref93) {
+  unlockDotCheckCanMint(_ref61) {
     let {
       address,
       network,
       slug
-    } = _ref93;
+    } = _ref61;
     return this.#koniState.mintCampaignService.unlockDotCampaign.canMint(address, slug, network);
   }
-  unlockDotSubscribeMintedData(id, port, _ref94) {
+  unlockDotSubscribeMintedData(id, port, _ref62) {
     let {
       transactionId
-    } = _ref94;
+    } = _ref62;
     const cb = (0, _subscriptions.createSubscription)(id, port);
     const subscription = this.#koniState.mintCampaignService.unlockDotCampaign.subscribeMintedNft(transactionId, cb);
     this.createUnsubscriptionHandle(id, subscription.unsubscribe);
@@ -4086,10 +3165,10 @@ class KoniExtension {
     });
     return filterBanner(await this.#koniState.campaignService.getProcessingCampaign());
   }
-  async completeCampaignBanner(_ref95) {
+  async completeCampaignBanner(_ref63) {
     let {
       slug
-    } = _ref95;
+    } = _ref63;
     const campaign = await this.#koniState.dbService.getCampaign(slug);
     if (campaign) {
       await this.#koniState.dbService.upsertCampaign({
@@ -4239,7 +3318,7 @@ class KoniExtension {
       recipient
     } = inputData;
     if (!quote || !address || !process) {
-      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)]);
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types2.BasicTxErrorType.INTERNAL_ERROR)]);
     }
     const isLastStep = inputData.currentStep + 1 === process.steps.length;
     const swapValidations = await this.#koniState.swapService.validateSwapProcess({
@@ -4310,22 +3389,8 @@ 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)':
@@ -4336,20 +3401,6 @@ 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)':
@@ -4428,14 +3479,6 @@ 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)':
@@ -4511,7 +3554,7 @@ 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)':
@@ -4520,6 +3563,14 @@ 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);
 
@@ -4528,43 +3579,54 @@ 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);
@@ -4622,8 +3684,6 @@ 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)':
@@ -4632,8 +3692,6 @@ 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)':
@@ -4666,12 +3724,14 @@ 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)':
@@ -4732,14 +3792,16 @@ 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)':
@@ -4845,6 +3907,8 @@ 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 */