@subwallet/extension-base 0.7.10-0 → 0.8.1-wr2x

package/koni/background/handlers/Extension.js

@@ -0,0 +1,3038 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import Common from '@ethereumjs/common';
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { isJsonPayload, SEED_DEFAULT_LENGTH, SEED_LENGTHS } from '@subwallet/extension-base/background/handlers/Extension';
+import { withErrorLog } from '@subwallet/extension-base/background/handlers/helpers';
+import { createSubscription } from '@subwallet/extension-base/background/handlers/subscriptions';
+import { AccountExternalErrorCode, BasicTxErrorType, ChainType, ExternalRequestPromiseStatus, ExtrinsicType, TransferTxErrorType } from '@subwallet/extension-base/background/KoniTypes';
+import { ALL_ACCOUNT_KEY, ALL_GENESIS_HASH } from '@subwallet/extension-base/constants';
+import { ALLOWED_PATH } from '@subwallet/extension-base/defaults';
+import { getFreeBalance, subscribeFreeBalance } from '@subwallet/extension-base/koni/api/dotsama/balance';
+import { parseSubstrateTransaction } from '@subwallet/extension-base/koni/api/dotsama/parseTransaction';
+import { checkReferenceCount, checkSupportTransfer, createTransferExtrinsic } from '@subwallet/extension-base/koni/api/dotsama/transfer';
+import { getNftTransferExtrinsic, isRecipientSelf } from '@subwallet/extension-base/koni/api/nft/transfer';
+import { getBondingExtrinsic, getCancelWithdrawalExtrinsic, getClaimRewardExtrinsic, getNominationPoolsInfo, getUnbondingExtrinsic, getValidatorsInfo, getWithdrawalExtrinsic } from '@subwallet/extension-base/koni/api/staking/bonding';
+import { getTuringCancelCompoundingExtrinsic, getTuringCompoundExtrinsic } from '@subwallet/extension-base/koni/api/staking/bonding/paraChain';
+import { getPoolingBondingExtrinsic, getPoolingUnbondingExtrinsic, getPoolingWithdrawalExtrinsic } from '@subwallet/extension-base/koni/api/staking/bonding/relayChain';
+import { getERC20TransactionObject, getERC721Transaction, getEVMTransactionObject } from '@subwallet/extension-base/koni/api/tokens/evm/transfer';
+import { getPSP34Transaction, getPSP34TransferExtrinsic } from '@subwallet/extension-base/koni/api/tokens/wasm';
+import { createXcmExtrinsic } from '@subwallet/extension-base/koni/api/xcm';
+import { _getChainNativeTokenBasicInfo, _getContractAddressOfToken, _getEvmChainId, _getSubstrateGenesisHash, _getTokenMinAmount, _isAssetSmartContractNft, _isChainEvmCompatible, _isCustomAsset, _isNativeToken, _isTokenEvmSmartContract } from '@subwallet/extension-base/services/chain-service/utils';
+import { EXTENSION_REQUEST_URL } from '@subwallet/extension-base/services/request-service/constants';
+import { createTransactionFromRLP, signatureToHex } from '@subwallet/extension-base/utils/eth';
+import { parseContractInput, parseEvmRlp } from '@subwallet/extension-base/utils/eth/parseTransaction';
+import { createPair } from '@subwallet/keyring';
+import { keyring } from '@subwallet/ui-keyring';
+import { accounts as accountsObservable } from '@subwallet/ui-keyring/observable/accounts';
+import BigN from 'bignumber.js';
+import { Transaction } from 'ethereumjs-tx';
+import { TypeRegistry } from '@polkadot/types';
+import { assert, BN, hexStripPrefix, hexToU8a, isAscii, isHex, u8aToHex, u8aToString } from '@polkadot/util';
+import { base64Decode, isEthereumAddress, jsonDecrypt, keyExtractSuri, mnemonicGenerate, mnemonicValidate } from '@polkadot/util-crypto';
+const ETH_DERIVE_DEFAULT = '/m/44\'/60\'/0\'/0/0';
+function getSuri(seed, type) {
+  return type === 'ethereum' ? `${seed}${ETH_DERIVE_DEFAULT}` : seed;
+}
+function transformAccounts(accounts) {
+  return Object.values(accounts).map(({
+    json: {
+      address,
+      meta
+    },
+    type
+  }) => ({
+    address,
+    ...meta,
+    type
+  }));
+}
+const ACCOUNT_ALL_JSON = {
+  address: ALL_ACCOUNT_KEY,
+  name: 'All'
+};
+export default class KoniExtension {
+  #koniState;
+  constructor(state) {
+    this.#koniState = state;
+  }
+
+  /// Clone from PolkadotJs
+  accountsCreateExternal({
+    address,
+    genesisHash,
+    name
+  }) {
+    keyring.addExternal(address, {
+      genesisHash,
+      name
+    });
+    return true;
+  }
+  accountsCreateHardware({
+    accountIndex,
+    address,
+    addressOffset,
+    genesisHash,
+    hardwareType,
+    name
+  }) {
+    keyring.addHardware(address, hardwareType, {
+      accountIndex,
+      addressOffset,
+      genesisHash,
+      name
+    });
+    return true;
+  }
+  accountsCreateSuri({
+    genesisHash,
+    name,
+    suri,
+    type
+  }) {
+    keyring.addUri(getSuri(suri, type), {
+      genesisHash,
+      name
+    }, type);
+    return true;
+  }
+  accountsChangePassword({
+    address,
+    newPass,
+    oldPass
+  }) {
+    const pair = keyring.getPair(address);
+    assert(pair, 'Unable to find pair');
+    try {
+      if (!pair.isLocked) {
+        pair.lock();
+      }
+      pair.decodePkcs8(oldPass);
+    } catch (error) {
+      throw new Error('oldPass is invalid');
+    }
+    keyring.encryptAccount(pair, newPass);
+    return true;
+  }
+  accountsEdit({
+    address,
+    name
+  }) {
+    const pair = keyring.getPair(address);
+    assert(pair, 'Unable to find pair');
+    keyring.saveAccountMeta(pair, {
+      ...pair.meta,
+      name
+    });
+    return true;
+  }
+  accountsExport({
+    address,
+    password
+  }) {
+    return {
+      exportedJson: keyring.backupAccount(keyring.getPair(address), password)
+    };
+  }
+  accountsShow({
+    address,
+    isShowing
+  }) {
+    const pair = keyring.getPair(address);
+    assert(pair, 'Unable to find pair');
+    keyring.saveAccountMeta(pair, {
+      ...pair.meta,
+      isHidden: !isShowing
+    });
+    return true;
+  }
+  accountsValidate({
+    address,
+    password
+  }) {
+    try {
+      keyring.backupAccount(keyring.getPair(address), password);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  // FIXME This looks very much like what we have in Tabs
+  accountsSubscribe(id, port) {
+    const cb = createSubscription(id, port);
+    const subscription = accountsObservable.subject.subscribe(accounts => cb(transformAccounts(accounts)));
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+      subscription.unsubscribe();
+    });
+    return true;
+  }
+  metadataApprove({
+    id
+  }) {
+    const queued = this.#koniState.getMetaRequest(id);
+    assert(queued, 'Unable to find request');
+    const {
+      request,
+      resolve
+    } = queued;
+    this.#koniState.saveMetadata(request);
+    resolve(true);
+    return true;
+  }
+  metadataGet(genesisHash) {
+    return this.#koniState.knownMetadata.find(result => result.genesisHash === genesisHash) || null;
+  }
+  metadataList() {
+    return this.#koniState.knownMetadata;
+  }
+  metadataReject({
+    id
+  }) {
+    const queued = this.#koniState.getMetaRequest(id);
+    assert(queued, 'Unable to find request');
+    const {
+      reject
+    } = queued;
+    reject(new Error('Rejected'));
+    return true;
+  }
+  metadataSubscribe(id, port) {
+    const cb = createSubscription(id, port);
+    const subscription = this.#koniState.metaSubject.subscribe(requests => cb(requests));
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+      subscription.unsubscribe();
+    });
+    return true;
+  }
+  jsonRestore({
+    file,
+    password
+  }) {
+    try {
+      keyring.restoreAccount(file, password, true);
+    } catch (error) {
+      throw new Error(error.message);
+    }
+  }
+  batchRestore({
+    file,
+    password
+  }) {
+    try {
+      keyring.restoreAccounts(file, password);
+    } catch (error) {
+      throw new Error(error.message);
+    }
+  }
+  jsonGetAccountInfo(json) {
+    try {
+      const {
+        address,
+        meta: {
+          genesisHash,
+          name
+        },
+        type
+      } = keyring.createFromJson(json);
+      return {
+        address,
+        genesisHash,
+        name,
+        type
+      };
+    } catch (e) {
+      console.error(e);
+      throw new Error(e.message);
+    }
+  }
+  seedCreate({
+    length = SEED_DEFAULT_LENGTH,
+    seed: _seed,
+    type
+  }) {
+    const seed = _seed || mnemonicGenerate(length);
+    return {
+      address: keyring.createFromUri(getSuri(seed, type), {}, type).address,
+      seed
+    };
+  }
+  seedValidate({
+    suri,
+    type
+  }) {
+    const {
+      phrase
+    } = keyExtractSuri(suri);
+    if (isHex(phrase)) {
+      assert(isHex(phrase, 256), 'Hex seed needs to be 256-bits');
+    } else {
+      // sadly isHex detects as string, so we need a cast here
+      assert(SEED_LENGTHS.includes(phrase.split(' ').length), `Mnemonic needs to contain ${SEED_LENGTHS.join(', ')} words`);
+      assert(mnemonicValidate(phrase), 'Not a valid mnemonic seed');
+    }
+    return {
+      address: keyring.createFromUri(getSuri(suri, type), {}, type).address,
+      suri
+    };
+  }
+  signingApproveSignature({
+    id,
+    signature
+  }) {
+    const queued = this.#koniState.getSignRequest(id);
+    assert(queued, 'Unable to find request');
+    const {
+      resolve
+    } = queued;
+    resolve({
+      id,
+      signature
+    });
+    return true;
+  }
+  signingCancel({
+    id
+  }) {
+    const queued = this.#koniState.getSignRequest(id);
+    assert(queued, 'Unable to find request');
+    const {
+      reject
+    } = queued;
+    reject(new Error('Cancelled'));
+    return true;
+  }
+
+  // FIXME This looks very much like what we have in authorization
+  signingSubscribe(id, port) {
+    const cb = createSubscription(id, port);
+    const subscription = this.#koniState.signSubject.subscribe(requests => cb(requests));
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+      subscription.unsubscribe();
+    });
+    return true;
+  }
+  windowOpen(path) {
+    const url = `${chrome.extension.getURL('index.html')}#${path}`;
+    if (!ALLOWED_PATH.includes(path)) {
+      console.error('Not allowed to open the url:', url);
+      return false;
+    }
+    withErrorLog(() => chrome.tabs.create({
+      url
+    }));
+    return true;
+  }
+  derive(parentAddress, suri, password, metadata) {
+    const parentPair = keyring.getPair(parentAddress);
+    try {
+      parentPair.decodePkcs8(password);
+    } catch (e) {
+      throw new Error('invalid password');
+    }
+    try {
+      return parentPair.derive(suri, metadata);
+    } catch (err) {
+      throw new Error(`"${suri}" is not a valid derivation path`);
+    }
+  }
+  derivationValidate({
+    parentAddress,
+    parentPassword,
+    suri
+  }) {
+    const childPair = this.derive(parentAddress, suri, parentPassword, {});
+    return {
+      address: childPair.address,
+      suri
+    };
+  }
+  derivationCreate({
+    genesisHash,
+    name,
+    parentAddress,
+    parentPassword,
+    suri
+  }) {
+    const childPair = this.derive(parentAddress, suri, parentPassword, {
+      genesisHash,
+      name,
+      parentAddress,
+      suri
+    });
+    keyring.addPair(childPair, true);
+    return true;
+  }
+
+  ///
+
+  cancelSubscription(id) {
+    return this.#koniState.cancelSubscription(id);
+  }
+  createUnsubscriptionHandle(id, unsubscribe) {
+    this.#koniState.createUnsubscriptionHandle(id, unsubscribe);
+  }
+  decodeAddress = (key, ignoreChecksum, ss58Format) => {
+    return keyring.decodeAddress(key, ignoreChecksum, ss58Format);
+  };
+  encodeAddress = (key, ss58Format) => {
+    return keyring.encodeAddress(key, ss58Format);
+  };
+  accountExportPrivateKey({
+    address,
+    password
+  }) {
+    return this.#koniState.accountExportPrivateKey({
+      address,
+      password
+    });
+  }
+  checkPublicAndSecretKey(request) {
+    return this.#koniState.checkPublicAndSecretKey(request);
+  }
+  async accountsGetAllWithCurrentAddress(id, port) {
+    const cb = createSubscription(id, port);
+    return await new Promise(resolve => {
+      const subscription = accountsObservable.subject.subscribe(storedAccounts => {
+        const transformedAccounts = transformAccounts(storedAccounts);
+        const accounts = transformedAccounts && transformedAccounts.length ? [{
+          ...ACCOUNT_ALL_JSON
+        }, ...transformedAccounts] : [];
+        const accountsWithCurrentAddress = {
+          accounts
+        };
+        setTimeout(() => {
+          this.#koniState.getCurrentAccount(accountInfo => {
+            if (accountInfo) {
+              accountsWithCurrentAddress.currentAddress = accountInfo.address;
+              if (accountInfo.address === ALL_ACCOUNT_KEY) {
+                accountsWithCurrentAddress.currentGenesisHash = accountInfo.currentGenesisHash;
+              } else {
+                const acc = accounts.find(a => a.address === accountInfo.address);
+                accountsWithCurrentAddress.currentGenesisHash = (acc === null || acc === void 0 ? void 0 : acc.genesisHash) || ALL_GENESIS_HASH;
+              }
+            }
+            resolve(accountsWithCurrentAddress);
+            cb(accountsWithCurrentAddress);
+          });
+        }, 300);
+      });
+      this.createUnsubscriptionHandle(id, subscription.unsubscribe);
+      port.onDisconnect.addListener(() => {
+        this.cancelSubscription(id);
+      });
+    });
+  }
+  accountsGetAll(id, port) {
+    const cb = createSubscription(id, port);
+    const subscription = keyring.keyringOption.optionsSubject.subscribe(options => {
+      const optionsInputAddress = {
+        options
+      };
+      cb(optionsInputAddress);
+    });
+    this.createUnsubscriptionHandle(id, subscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return id;
+  }
+  saveRecentAccountId({
+    accountId
+  }) {
+    return keyring.saveRecent(accountId);
+  }
+  triggerAccountsSubscription() {
+    const accountsSubject = accountsObservable.subject;
+    accountsSubject.next(accountsSubject.getValue());
+    return true;
+  }
+  _getAuthListV2() {
+    return new Promise((resolve, reject) => {
+      this.#koniState.getAuthorize(rs => {
+        const accounts = accountsObservable.subject.getValue();
+        const addressList = Object.keys(accounts);
+        const urlList = Object.keys(rs);
+        if (Object.keys(rs[urlList[0]].isAllowedMap).toString() !== addressList.toString()) {
+          urlList.forEach(url => {
+            addressList.forEach(address => {
+              if (!Object.keys(rs[url].isAllowedMap).includes(address)) {
+                rs[url].isAllowedMap[address] = false;
+              }
+            });
+            Object.keys(rs[url].isAllowedMap).forEach(address => {
+              if (!addressList.includes(address)) {
+                delete rs[url].isAllowedMap[address];
+              }
+            });
+          });
+          this.#koniState.setAuthorize(rs);
+        }
+        resolve(rs);
+      });
+    });
+  }
+  authorizeSubscribeV2(id, port) {
+    const cb = createSubscription(id, port);
+    const subscription = this.#koniState.authSubjectV2.subscribe(requests => cb(requests));
+    this.createUnsubscriptionHandle(id, subscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return true;
+  }
+  async getAuthListV2() {
+    const authList = await this._getAuthListV2();
+    return {
+      list: authList
+    };
+  }
+  authorizeApproveV2({
+    accounts,
+    id
+  }) {
+    const queued = this.#koniState.getAuthRequestV2(id);
+    assert(queued, 'Unable to find request');
+    const {
+      resolve
+    } = queued;
+    resolve({
+      accounts,
+      result: true
+    });
+    return true;
+  }
+  authorizeRejectV2({
+    id
+  }) {
+    const queued = this.#koniState.getAuthRequestV2(id);
+    assert(queued, 'Unable to find request');
+    const {
+      reject
+    } = queued;
+    reject(new Error('Rejected'));
+    return true;
+  }
+  authorizeCancelV2({
+    id
+  }) {
+    const queued = this.#koniState.getAuthRequestV2(id);
+    assert(queued, 'Unable to find request');
+    const {
+      reject
+    } = queued;
+
+    // Reject without error meaning cancel
+    reject(new Error('Cancelled'));
+    return true;
+  }
+  _forgetSite(url, callBack) {
+    this.#koniState.getAuthorize(value => {
+      assert(value, 'The source is not known');
+      delete value[url];
+      this.#koniState.setAuthorize(value, () => {
+        callBack && callBack(value);
+      });
+    });
+  }
+  forgetSite(data, id, port) {
+    const cb = createSubscription(id, port);
+    this._forgetSite(data.url, items => {
+      cb(items);
+    });
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return true;
+  }
+  _forgetAllSite(callBack) {
+    this.#koniState.getAuthorize(value => {
+      assert(value, 'The source is not known');
+      value = {};
+      this.#koniState.setAuthorize(value, () => {
+        callBack && callBack(value);
+      });
+    });
+  }
+  forgetAllSite(id, port) {
+    const cb = createSubscription(id, port);
+    this._forgetAllSite(items => {
+      cb(items);
+    });
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return true;
+  }
+  getNonReadonlyAccounts() {
+    const storedAccounts = accountsObservable.subject.getValue();
+    const transformedAccounts = transformAccounts(storedAccounts);
+    return transformedAccounts.filter(a => !a.isReadOnly).map(a => a.address);
+  }
+  filterAccountsByAccountAuthType(accounts, accountAuthType) {
+    if (accountAuthType === 'substrate') {
+      return accounts.filter(address => !isEthereumAddress(address));
+    } else if (accountAuthType === 'evm') {
+      return accounts.filter(address => isEthereumAddress(address));
+    } else {
+      return accounts;
+    }
+  }
+  _changeAuthorizationAll(connectValue, callBack) {
+    this.#koniState.getAuthorize(value => {
+      assert(value, 'The source is not known');
+      const nonReadonlyAccounts = this.getNonReadonlyAccounts();
+      Object.keys(value).forEach(url => {
+        const targetAccounts = this.filterAccountsByAccountAuthType(nonReadonlyAccounts, value[url].accountAuthType);
+        targetAccounts.forEach(address => {
+          value[url].isAllowedMap[address] = connectValue;
+        });
+      });
+      this.#koniState.setAuthorize(value, () => {
+        callBack && callBack(value);
+      });
+    });
+  }
+  changeAuthorizationAll(data, id, port) {
+    const cb = createSubscription(id, port);
+    this._changeAuthorizationAll(data.connectValue, items => {
+      cb(items);
+    });
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return true;
+  }
+  _changeAuthorization(url, connectValue, callBack) {
+    this.#koniState.getAuthorize(value => {
+      assert(value[url], 'The source is not known');
+      const nonReadonlyAccounts = this.getNonReadonlyAccounts();
+      const targetAccounts = this.filterAccountsByAccountAuthType(nonReadonlyAccounts, value[url].accountAuthType);
+      targetAccounts.forEach(address => {
+        value[url].isAllowedMap[address] = connectValue;
+      });
+      this.#koniState.setAuthorize(value, () => {
+        callBack && callBack(value);
+      });
+    });
+  }
+  toggleAuthorization2(url) {
+    return new Promise(resolve => {
+      this.#koniState.getAuthorize(value => {
+        assert(value[url], 'The source is not known');
+        value[url].isAllowed = !value[url].isAllowed;
+        this.#koniState.setAuthorize(value, () => {
+          resolve({
+            list: value
+          });
+        });
+      });
+    });
+  }
+  changeAuthorization(data, id, port) {
+    const cb = createSubscription(id, port);
+    this._changeAuthorization(data.url, data.connectValue, items => {
+      cb(items);
+    });
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return true;
+  }
+  _changeAuthorizationPerAcc(address, connectValue, url, callBack) {
+    this.#koniState.getAuthorize(value => {
+      assert(value, 'The source is not known');
+      value[url].isAllowedMap[address] = connectValue;
+      console.log('Devbu: ', value);
+      this.#koniState.setAuthorize(value, () => {
+        callBack && callBack(value);
+      });
+    });
+  }
+  _changeAuthorizationBlock(connectValue, id) {
+    this.#koniState.getAuthorize(value => {
+      assert(value, 'The source is not known');
+      value[id].isAllowed = connectValue;
+      console.log('Devbu: ', value);
+      this.#koniState.setAuthorize(value);
+    });
+  }
+  _changeAuthorizationPerSite(values, id) {
+    this.#koniState.getAuthorize(value => {
+      assert(value, 'The source is not known');
+      value[id].isAllowedMap = values;
+      console.log('Devbu: ', value);
+      this.#koniState.setAuthorize(value);
+    });
+  }
+  changeAuthorizationPerAcc(data, id, port) {
+    const cb = createSubscription(id, port);
+    this._changeAuthorizationPerAcc(data.address, data.connectValue, data.url, items => {
+      cb(items);
+    });
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return true;
+  }
+  changeAuthorizationPerSite(data) {
+    this._changeAuthorizationPerSite(data.values, data.id);
+    return true;
+  }
+  changeAuthorizationBlock(data) {
+    this._changeAuthorizationBlock(data.connectedValue, data.id);
+    return true;
+  }
+  async getSettings() {
+    return await new Promise(resolve => {
+      this.#koniState.getSettings(value => {
+        resolve(value);
+      });
+    });
+  }
+  toggleBalancesVisibility(id, port) {
+    const cb = createSubscription(id, port);
+    this.#koniState.getSettings(value => {
+      const updateValue = {
+        ...value,
+        isShowBalance: !value.isShowBalance
+      };
+      this.#koniState.setSettings(updateValue, () => {
+        // eslint-disable-next-line node/no-callback-literal
+        cb(updateValue);
+      });
+    });
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return true;
+  }
+  saveAccountAllLogo(data, id, port) {
+    const cb = createSubscription(id, port);
+    this.#koniState.getSettings(value => {
+      const updateValue = {
+        ...value,
+        accountAllLogo: data
+      };
+      this.#koniState.setSettings(updateValue, () => {
+        // eslint-disable-next-line node/no-callback-literal
+        cb(updateValue);
+      });
+    });
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return true;
+  }
+  saveTheme(data, id, port) {
+    const cb = createSubscription(id, port);
+    this.#koniState.setTheme(data, cb);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return true;
+  }
+  saveBrowserConfirmationType(data, id, port) {
+    const cb = createSubscription(id, port);
+    this.#koniState.setBrowserConfirmationType(data, cb);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return true;
+  }
+  async subscribeSettings(id, port) {
+    const cb = createSubscription(id, port);
+    const balancesVisibilitySubscription = this.#koniState.subscribeSettingsSubject().subscribe({
+      next: rs => {
+        cb(rs);
+      }
+    });
+    this.createUnsubscriptionHandle(id, balancesVisibilitySubscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return await this.getSettings();
+  }
+  async subscribeAuthUrls(id, port) {
+    const cb = createSubscription(id, port);
+    const authorizeUrlSubscription = this.#koniState.subscribeAuthorizeUrlSubject().subscribe({
+      next: rs => {
+        cb(rs);
+      }
+    });
+    this.createUnsubscriptionHandle(id, authorizeUrlSubscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return await this.#koniState.getAuthList();
+  }
+  _saveCurrentAccountAddress(address, callback) {
+    this.#koniState.getCurrentAccount(accountInfo => {
+      if (!accountInfo) {
+        accountInfo = {
+          address,
+          currentGenesisHash: ALL_GENESIS_HASH,
+          allGenesisHash: ALL_GENESIS_HASH || undefined
+        };
+      } else {
+        accountInfo.address = address;
+        if (address !== ALL_ACCOUNT_KEY) {
+          const currentKeyPair = keyring.getAccount(address);
+          accountInfo.currentGenesisHash = (currentKeyPair === null || currentKeyPair === void 0 ? void 0 : currentKeyPair.meta.genesisHash) || ALL_GENESIS_HASH;
+        } else {
+          accountInfo.currentGenesisHash = accountInfo.allGenesisHash || ALL_GENESIS_HASH;
+        }
+      }
+      this.#koniState.setCurrentAccount(accountInfo, () => {
+        callback && callback(accountInfo);
+      });
+    });
+  }
+  updateCurrentAccountAddress(address) {
+    this._saveCurrentAccountAddress(address, () => {
+      this.triggerAccountsSubscription();
+    });
+    return true;
+  }
+  saveCurrentAccountAddress(data, id, port) {
+    const cb = createSubscription(id, port);
+    this._saveCurrentAccountAddress(data.address, cb);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return true;
+  }
+  getAssetSetting() {
+    return new Promise((resolve, reject) => {
+      this.#koniState.getAssetSettings(rs => {
+        resolve(rs);
+      });
+    });
+  }
+  subscribeAssetSetting(id, port) {
+    const cb = createSubscription(id, port);
+    const assetSettingSubscription = this.#koniState.subscribeAssetSettings().subscribe({
+      next: rs => {
+        cb(rs);
+      }
+    });
+    this.createUnsubscriptionHandle(id, assetSettingSubscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return this.getAssetSetting();
+  }
+  updateAssetSetting(params) {
+    try {
+      this.#koniState.updateAssetSetting(params.tokenSlug, params.assetSetting);
+      return true;
+    } catch (e) {
+      console.error('Error updating asset setting', e);
+      return false;
+    }
+  }
+  async getPrice() {
+    return this.#koniState.priceService.getPrice();
+  }
+  subscribePrice(id, port) {
+    const cb = createSubscription(id, port);
+    const priceSubscription = this.#koniState.priceService.getPriceSubject().subscribe(rs => {
+      cb(rs);
+    });
+    this.createUnsubscriptionHandle(id, priceSubscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return this.getPrice();
+  }
+  getBalance(reset) {
+    return this.#koniState.getBalance(reset);
+  }
+  subscribeBalance(id, port) {
+    const cb = createSubscription(id, port);
+    const balanceSubscription = this.#koniState.subscribeBalance().subscribe({
+      next: rs => {
+        cb(rs);
+      }
+    });
+    this.createUnsubscriptionHandle(id, balanceSubscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return this.getBalance(true);
+  }
+  getCrowdloan(reset) {
+    return this.#koniState.getCrowdloan(reset);
+  }
+  subscribeCrowdloan(id, port) {
+    const cb = createSubscription(id, port);
+    const crowdloanSubscription = this.#koniState.subscribeCrowdloan().subscribe({
+      next: rs => {
+        cb(rs);
+      }
+    });
+    this.createUnsubscriptionHandle(id, crowdloanSubscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return this.getCrowdloan(true);
+  }
+  validatePassword(json, password) {
+    const cryptoType = Array.isArray(json.encoding.content) ? json.encoding.content[1] : 'ed25519';
+    const encType = Array.isArray(json.encoding.type) ? json.encoding.type : [json.encoding.type];
+    const pair = createPair({
+      toSS58: this.encodeAddress,
+      type: cryptoType
+    }, {
+      publicKey: this.decodeAddress(json.address, true)
+    }, json.meta, isHex(json.encoded) ? hexToU8a(json.encoded) : base64Decode(json.encoded), encType);
+
+    // unlock then lock (locking cleans secretKey, so needs to be last)
+    try {
+      pair.decodePkcs8(password);
+      pair.lock();
+      return true;
+    } catch (e) {
+      console.error(e);
+      return false;
+    }
+  }
+  validatedAccountsPassword(json, password) {
+    try {
+      u8aToString(jsonDecrypt(json, password));
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  _addAddressToAuthList(address, isAllowed) {
+    this.#koniState.getAuthorize(value => {
+      if (value && Object.keys(value).length) {
+        Object.keys(value).forEach(url => {
+          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 => {
+            value[url].isAllowedMap[address] = isAllowed;
+          });
+        }); /**/
+
+        this.#koniState.setAuthorize(value);
+      }
+    });
+  }
+  async accountsCreateSuriV2({
+    genesisHash,
+    isAllowed,
+    name,
+    password,
+    suri: _suri,
+    types
+  }) {
+    const addressDict = {};
+    let changedAccount = false;
+    const hasMasterPassword = keyring.keyring.hasMasterPassword;
+    if (!hasMasterPassword) {
+      if (!password) {
+        throw Error('Require password to set up master password');
+      } else {
+        keyring.changeMasterPassword(password);
+        this.#koniState.setKeyringState({
+          hasMasterPassword: true,
+          isLocked: false,
+          isReady: true
+        });
+      }
+    }
+    const currentAccount = await new Promise(resolve => {
+      this.#koniState.getCurrentAccount(resolve);
+    });
+    const allGenesisHash = (currentAccount === null || currentAccount === void 0 ? void 0 : currentAccount.allGenesisHash) || undefined;
+    types === null || types === void 0 ? void 0 : types.forEach(type => {
+      const suri = getSuri(_suri, type);
+      const address = keyring.createFromUri(suri, {}, type).address;
+      addressDict[type] = address;
+      const newAccountName = type === 'ethereum' ? `${name} - EVM` : name;
+      keyring.addUri(suri, {
+        genesisHash,
+        name: newAccountName
+      }, type);
+      this._addAddressToAuthList(address, isAllowed);
+      if (!changedAccount) {
+        if (types.length === 1) {
+          this.#koniState.setCurrentAccount({
+            address,
+            currentGenesisHash: genesisHash || null,
+            allGenesisHash
+          });
+        } else {
+          this.#koniState.setCurrentAccount({
+            address: ALL_ACCOUNT_KEY,
+            currentGenesisHash: allGenesisHash || null,
+            allGenesisHash
+          });
+        }
+        changedAccount = true;
+      }
+    });
+    await new Promise(resolve => {
+      this.#koniState.addAccountRef(Object.values(addressDict), () => {
+        resolve();
+      });
+    });
+    return addressDict;
+  }
+  async accountsForgetOverride({
+    address
+  }) {
+    keyring.forgetAccount(address);
+    await new Promise(resolve => {
+      this.#koniState.removeAccountRef(address, () => {
+        resolve();
+      });
+    });
+    await new Promise(resolve => {
+      this.#koniState.getAuthorize(value => {
+        if (value && Object.keys(value).length) {
+          Object.keys(value).forEach(url => {
+            delete value[url].isAllowedMap[address];
+          });
+          this.#koniState.setAuthorize(value, resolve);
+        } else {
+          resolve();
+        }
+      });
+    });
+
+    // Set current account to all account
+    await new Promise(resolve => {
+      this.#koniState.getCurrentAccount(({
+        allGenesisHash
+      }) => {
+        this.#koniState.setCurrentAccount({
+          currentGenesisHash: allGenesisHash || null,
+          address: ALL_ACCOUNT_KEY
+        }, resolve);
+      });
+    });
+    return true;
+  }
+  seedCreateV2({
+    length = SEED_DEFAULT_LENGTH,
+    seed: _seed,
+    types
+  }) {
+    const seed = _seed || mnemonicGenerate(length);
+    const rs = {
+      seed: seed,
+      addressMap: {}
+    };
+    types === null || types === void 0 ? void 0 : types.forEach(type => {
+      rs.addressMap[type] = keyring.createFromUri(getSuri(seed, type), {}, type).address;
+    });
+    return rs;
+  }
+  seedValidateV2({
+    suri,
+    types
+  }) {
+    const {
+      phrase
+    } = keyExtractSuri(suri);
+    if (isHex(phrase)) {
+      assert(isHex(phrase, 256), 'Hex seed needs to be 256-bits');
+    } else {
+      // sadly isHex detects as string, so we need a cast here
+      assert(SEED_LENGTHS.includes(phrase.split(' ').length), `Mnemonic needs to contain ${SEED_LENGTHS.join(', ')} words`);
+      assert(mnemonicValidate(phrase), 'Not a valid mnemonic seed');
+    }
+    const rs = {
+      seed: suri,
+      addressMap: {}
+    };
+    types && types.forEach(type => {
+      rs.addressMap[type] = keyring.createFromUri(getSuri(suri, type), {}, type).address;
+    });
+    return rs;
+  }
+  _checkValidatePrivateKey({
+    suri,
+    types
+  }, autoAddPrefix = false) {
+    const {
+      phrase
+    } = keyExtractSuri(suri);
+    const rs = {
+      autoAddPrefix: autoAddPrefix,
+      addressMap: {}
+    };
+    types && types.forEach(type => {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      rs.addressMap[type] = '';
+    });
+    if (isHex(phrase) && isHex(phrase, 256)) {
+      types && types.forEach(type => {
+        rs.addressMap[type] = keyring.createFromUri(getSuri(suri, type), {}, type).address;
+      });
+    } else {
+      rs.autoAddPrefix = false;
+      assert(false, 'Not valid private key');
+    }
+    return rs;
+  }
+  metamaskPrivateKeyValidateV2({
+    suri,
+    types
+  }) {
+    const isValidSuri = suri.startsWith('0x');
+    if (isValidSuri) {
+      return this._checkValidatePrivateKey({
+        suri,
+        types
+      });
+    } else {
+      return this._checkValidatePrivateKey({
+        suri: `0x${suri}`,
+        types
+      }, true);
+    }
+  }
+  deriveV2(parentAddress, suri, metadata) {
+    const parentPair = keyring.getPair(parentAddress);
+    if (parentPair.isLocked) {
+      keyring.unlockPair(parentPair.address);
+    }
+    try {
+      return parentPair.derive(suri, metadata);
+    } catch (err) {
+      throw new Error(`"${suri}" is not a valid derivation path`);
+    }
+  }
+  derivationCreateV2({
+    genesisHash,
+    isAllowed,
+    name,
+    parentAddress,
+    suri
+  }) {
+    const childPair = this.deriveV2(parentAddress, suri, {
+      genesisHash,
+      name,
+      parentAddress,
+      suri
+    });
+    const address = childPair.address;
+    this._saveCurrentAccountAddress(address, () => {
+      keyring.addPair(childPair, true);
+      this._addAddressToAuthList(address, isAllowed);
+    });
+    return true;
+  }
+  jsonRestoreV2({
+    address,
+    file,
+    isAllowed,
+    password,
+    withMasterPassword
+  }) {
+    const isPasswordValidated = this.validatePassword(file, password);
+    if (isPasswordValidated) {
+      try {
+        this._saveCurrentAccountAddress(address, () => {
+          keyring.restoreAccount(file, password, withMasterPassword);
+          this._addAddressToAuthList(address, isAllowed);
+        });
+      } catch (error) {
+        throw new Error(error.message);
+      }
+    } else {
+      throw new Error('Unable to decode using the supplied passphrase');
+    }
+  }
+  batchRestoreV2({
+    accountsInfo,
+    file,
+    isAllowed,
+    password
+  }) {
+    const addressList = accountsInfo.map(acc => acc.address);
+    const isPasswordValidated = this.validatedAccountsPassword(file, password);
+    if (isPasswordValidated) {
+      try {
+        this._saveCurrentAccountAddress(addressList[0], () => {
+          keyring.restoreAccounts(file, password);
+          this._addAddressesToAuthList(addressList, isAllowed);
+        });
+      } catch (error) {
+        throw new Error(error.message);
+      }
+    } else {
+      throw new Error('Unable to decode using the supplied passphrase');
+    }
+  }
+  getNftTransfer() {
+    return new Promise((resolve, reject) => {
+      this.#koniState.getNftTransferSubscription(rs => {
+        resolve(rs);
+      });
+    });
+  }
+  async subscribeNftTransfer(id, port) {
+    const cb = createSubscription(id, port);
+    const nftTransferSubscription = this.#koniState.subscribeNftTransfer().subscribe({
+      next: rs => {
+        cb(rs);
+      }
+    });
+    this.createUnsubscriptionHandle(id, nftTransferSubscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return this.getNftTransfer();
+  }
+  getNftCollection() {
+    return this.#koniState.getNftCollection();
+  }
+  subscribeNftCollection(id, port) {
+    const cb = createSubscription(id, port);
+    const nftCollectionSubscription = this.#koniState.subscribeNftCollection().subscribe({
+      next: rs => {
+        cb(rs);
+      }
+    });
+    this.createUnsubscriptionHandle(id, nftCollectionSubscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return this.getNftCollection();
+  }
+  getNft() {
+    return this.#koniState.getNft();
+  }
+  async subscribeNft(id, port) {
+    const cb = createSubscription(id, port);
+    const nftSubscription = this.#koniState.subscribeNft().subscribe({
+      next: rs => {
+        cb(rs);
+      }
+    });
+    this.createUnsubscriptionHandle(id, nftSubscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return this.getNft();
+  }
+  getStakingReward() {
+    return new Promise((resolve, reject) => {
+      this.#koniState.getStakingReward(rs => {
+        resolve(rs);
+      });
+    });
+  }
+  subscribeStakingReward(id, port) {
+    const cb = createSubscription(id, port);
+    const stakingRewardSubscription = this.#koniState.subscribeStakingReward().subscribe({
+      next: rs => {
+        cb(rs);
+      }
+    });
+    this.createUnsubscriptionHandle(id, stakingRewardSubscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return this.getStakingReward();
+  }
+  async getStaking() {
+    return this.#koniState.getStaking();
+  }
+  async subscribeStaking(id, port) {
+    const cb = createSubscription(id, port);
+    const stakingSubscription = this.#koniState.subscribeStaking().subscribe({
+      next: rs => {
+        cb(rs);
+      }
+    });
+    this.createUnsubscriptionHandle(id, stakingSubscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return await this.getStaking();
+  }
+  async subscribeHistory(id, port) {
+    const cb = createSubscription(id, port);
+    const historySubject = await this.#koniState.historyService.getHistorySubject();
+    historySubject.subscribe(cb);
+    this.createUnsubscriptionHandle(id, historySubject.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return historySubject.getValue();
+  }
+  setNftTransfer(request) {
+    this.#koniState.setNftTransfer(request);
+    return true;
+  }
+  forceUpdateNftState(request) {
+    if (!request.isSendingSelf) {
+      this.#koniState.removeNfts(request.chain, request.senderAddress, request.collectionId, [request.nft.id || '']).catch(e => console.warn(e));
+      this.isInWalletAccount(request.recipientAddress).then(res => {
+        if (res) {
+          this.#koniState.updateNftData(request.chain, request.nft, request.recipientAddress);
+        }
+      }).catch(err => console.warn(err));
+    }
+    return true;
+  }
+  validateTransfer(tokenSlug, from, to, value, transferAll) {
+    const errors = [];
+    const keypair = keyring.getPair(from);
+    let transferValue;
+    if (!transferAll) {
+      if (value === undefined) {
+        errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, 'Require transfer value'));
+      }
+      if (value) {
+        transferValue = new BN(value);
+      }
+    }
+    const tokenInfo = this.#koniState.getAssetBySlug(tokenSlug);
+    if (!tokenInfo) {
+      errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, 'Not found token from registry'));
+    }
+    if (isEthereumAddress(from) && isEthereumAddress(to) && !_isNativeToken(tokenInfo) && !_isTokenEvmSmartContract(tokenInfo)) {
+      errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, 'Not found ERC20 address for this token'));
+    }
+    return [errors, keypair, transferValue, tokenInfo];
+  }
+  async makeTransfer(inputData) {
+    const {
+      from,
+      networkKey,
+      to,
+      tokenSlug,
+      transferAll,
+      value
+    } = inputData;
+    const [errors,,, tokenInfo] = this.validateTransfer(tokenSlug, from, to, value, transferAll);
+    const warnings = [];
+    const substrateApiMap = this.#koniState.getSubstrateApiMap();
+    const evmApiMap = this.#koniState.getEvmApiMap();
+    const chainInfo = this.#koniState.getChainInfo(networkKey);
+    const nativeTokenInfo = this.#koniState.getNativeTokenInfo(networkKey);
+    const nativeTokenSlug = nativeTokenInfo.slug;
+    const isTransferNativeToken = nativeTokenSlug === tokenSlug;
+    let chainType = ChainType.SUBSTRATE;
+    const tokenBaseAmount = {
+      value: '0',
+      symbol: tokenInfo.symbol,
+      decimals: tokenInfo.decimals || 0
+    };
+    const transferAmount = {
+      ...tokenBaseAmount
+    };
+    let transaction;
+
+    // Get native token amount
+    const freeBalance = await getFreeBalance(networkKey, from, substrateApiMap, evmApiMap, tokenSlug);
+    if (isEthereumAddress(from) && isEthereumAddress(to)) {
+      chainType = ChainType.EVM;
+      const txVal = transferAll ? freeBalance : value || '0';
+
+      // Estimate with EVM API
+      if (_isTokenEvmSmartContract(tokenInfo)) {
+        [transaction, transferAmount.value] = await getERC20TransactionObject(_getContractAddressOfToken(tokenInfo), chainInfo, from, to, txVal, !!transferAll, evmApiMap);
+      } else {
+        [transaction, transferAmount.value] = await getEVMTransactionObject(chainInfo, to, txVal, !!transferAll, evmApiMap);
+      }
+    } else {
+      const substrateApi = this.#koniState.getSubstrateApi(networkKey);
+      [transaction, transferAmount.value] = await createTransferExtrinsic({
+        transferAll: !!transferAll,
+        value: value || '0',
+        from: from,
+        networkKey,
+        tokenInfo,
+        to: to,
+        substrateApi
+      });
+    }
+
+    // Additional validator
+    const additionalValidator = swTran => {
+      if (new BN(freeBalance).lt(new BN(transferAmount.value))) {
+        var _swTran$errors;
+        (_swTran$errors = swTran.errors) === null || _swTran$errors === void 0 ? void 0 : _swTran$errors.push(new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE));
+      }
+      return Promise.resolve();
+    };
+    return this.#koniState.transactionService.handleTransaction({
+      errors,
+      warnings,
+      address: from,
+      chain: networkKey,
+      chainType,
+      transferNativeAmount: isTransferNativeToken ? transferAmount.value : '0',
+      transaction,
+      data: inputData,
+      additionalValidator,
+      extrinsicType: isTransferNativeToken ? ExtrinsicType.TRANSFER_BALANCE : ExtrinsicType.TRANSFER_TOKEN
+    });
+  }
+  validateCrossChainTransfer(destinationNetworkKey, sendingTokenSlug, sender, sendingValue) {
+    const errors = [];
+    const keypair = keyring.getPair(sender);
+    const transferValue = new BN(sendingValue);
+    const originTokenInfo = this.#koniState.getAssetBySlug(sendingTokenSlug);
+    const destinationTokenInfo = this.#koniState.getXcmEqualAssetByChain(destinationNetworkKey, sendingTokenSlug);
+    if (!destinationTokenInfo) {
+      errors.push(new TransactionError(TransferTxErrorType.INVALID_TOKEN, 'Not found token from registry'));
+    }
+    return [errors, keypair, transferValue, originTokenInfo, destinationTokenInfo];
+  }
+  async makeCrossChainTransfer(inputData) {
+    const {
+      destinationNetworkKey,
+      from,
+      originNetworkKey,
+      sendingTokenSlug,
+      to,
+      value
+    } = inputData;
+    const [errors, fromKeyPair,, originTokenInfo, destinationTokenInfo] = this.validateCrossChainTransfer(destinationNetworkKey, sendingTokenSlug, from, value);
+    let extrinsic = null;
+    if (errors) {
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors(errors);
+    }
+    if (fromKeyPair && destinationTokenInfo) {
+      const substrateApiMap = this.#koniState.getSubstrateApiMap();
+      const chainInfoMap = this.#koniState.getChainInfoMap();
+      extrinsic = await createXcmExtrinsic({
+        destinationTokenInfo,
+        originTokenInfo,
+        sendingValue: value || '0',
+        recipient: to,
+        chainInfoMap: chainInfoMap,
+        substrateApiMap: substrateApiMap
+      });
+    }
+    return await this.#koniState.transactionService.handleTransaction({
+      url: EXTENSION_REQUEST_URL,
+      address: from,
+      chain: originNetworkKey,
+      transaction: extrinsic,
+      data: inputData,
+      extrinsicType: ExtrinsicType.TRANSFER_XCM,
+      chainType: ChainType.SUBSTRATE,
+      transferNativeAmount: _isNativeToken(originTokenInfo) ? value : '0',
+      errors
+    });
+  }
+  async evmNftSubmitTransaction(inputData) {
+    const {
+      networkKey,
+      params,
+      recipientAddress,
+      senderAddress
+    } = inputData;
+    const contractAddress = params.contractAddress;
+    const tokenId = params.tokenId;
+    console.log(inputData);
+    const transaction = await getERC721Transaction(this.#koniState.getEvmApi(networkKey), contractAddress, senderAddress, recipientAddress, tokenId);
+    return await this.#koniState.transactionService.handleTransaction({
+      address: senderAddress,
+      chain: networkKey,
+      chainType: ChainType.EVM,
+      data: inputData,
+      extrinsicType: ExtrinsicType.SEND_NFT,
+      transaction,
+      url: EXTENSION_REQUEST_URL
+    });
+  }
+  upsertChain(data) {
+    try {
+      return this.#koniState.upsertChainInfo(data);
+    } catch (e) {
+      console.error(e);
+      return false;
+    }
+  }
+  removeCustomChain(networkKey) {
+    return this.#koniState.removeCustomChain(networkKey);
+  }
+  disableChain(networkKey) {
+    return this.#koniState.disableChain(networkKey);
+  }
+  enableChain(networkKey) {
+    return this.#koniState.enableChain(networkKey);
+  }
+  async validateNetwork({
+    existedChainSlug,
+    provider
+  }) {
+    return await this.#koniState.validateCustomChain(provider, existedChainSlug);
+  }
+  resetDefaultNetwork() {
+    return this.#koniState.resetDefaultChains();
+  }
+  recoverDotSamaApi(networkKey) {
+    try {
+      return this.#koniState.refreshSubstrateApi(networkKey);
+    } catch (e) {
+      console.error('error recovering substrate api', e);
+      return false;
+    }
+  }
+  upsertCustomToken(data) {
+    try {
+      this.#koniState.upsertCustomToken(data);
+      return true;
+    } catch (e) {
+      console.error('Error insert/update custom token', e);
+      return false;
+    }
+  }
+  async deleteCustomAsset(assetSlug) {
+    const assetInfo = this.#koniState.getAssetBySlug(assetSlug);
+    if (assetInfo && _isCustomAsset(assetSlug)) {
+      if (_isAssetSmartContractNft(assetInfo)) {
+        // check if deleting a smart contract NFT
+        await this.#koniState.deleteNftCollection(assetInfo.originChain, _getContractAddressOfToken(assetInfo));
+      }
+      this.#koniState.deleteCustomAssets([assetSlug]);
+      return true;
+    }
+    return false;
+  }
+  async validateCustomAsset(data) {
+    return await this.#koniState.validateCustomAsset(data);
+  }
+  async subscribeAddressFreeBalance({
+    address,
+    networkKey,
+    token
+  }, id, port) {
+    const cb = createSubscription(id, port);
+    this.createUnsubscriptionHandle(id, await subscribeFreeBalance(networkKey, address, this.#koniState.getSubstrateApiMap(), this.#koniState.getEvmApiMap(), token, cb));
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return id;
+  }
+  async transferCheckReferenceCount({
+    address,
+    networkKey
+  }) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-return
+    return await checkReferenceCount(networkKey, address, this.#koniState.getSubstrateApiMap(), this.#koniState.getChainInfo(networkKey));
+  }
+  async transferCheckSupporting({
+    networkKey,
+    tokenSlug
+  }) {
+    const tokenInfo = this.#koniState.getAssetBySlug(tokenSlug);
+    return await checkSupportTransfer(networkKey, tokenInfo, this.#koniState.getSubstrateApiMap(), this.#koniState.getChainInfo(networkKey));
+  }
+  transferGetExistentialDeposit({
+    tokenSlug
+  }) {
+    const tokenInfo = this.#koniState.getAssetBySlug(tokenSlug);
+    return _getTokenMinAmount(tokenInfo);
+  }
+  async substrateNftSubmitTransaction(inputData) {
+    const {
+      params,
+      recipientAddress,
+      senderAddress
+    } = inputData;
+    const isSendingSelf = isRecipientSelf(senderAddress, recipientAddress);
+
+    // TODO: do better to detect tokenType
+    const isPSP34 = params === null || params === void 0 ? void 0 : params.isPsp34;
+    const networkKey = params === null || params === void 0 ? void 0 : params.networkKey;
+    const apiProps = this.#koniState.getSubstrateApi(networkKey);
+    const extrinsic = !isPSP34 ? getNftTransferExtrinsic(networkKey, apiProps, senderAddress, recipientAddress, params || {}) : await getPSP34TransferExtrinsic(networkKey, apiProps, senderAddress, recipientAddress, params || {});
+    const rs = await this.#koniState.transactionService.handleTransaction({
+      address: senderAddress,
+      chain: networkKey,
+      transaction: extrinsic,
+      data: {
+        ...inputData,
+        isSendingSelf
+      },
+      extrinsicType: ExtrinsicType.SEND_NFT,
+      chainType: ChainType.SUBSTRATE
+    });
+    return {
+      ...rs,
+      isSendingSelf
+    };
+  }
+  enableChains(targetKeys) {
+    try {
+      for (const networkKey of targetKeys) {
+        this.enableChain(networkKey);
+      }
+    } catch (e) {
+      return false;
+    }
+    return true;
+  }
+  getAccountMeta({
+    address
+  }) {
+    const pair = keyring.getPair(address);
+    assert(pair, 'Unable to find pair');
+    return {
+      meta: pair.meta
+    };
+  }
+  async isInWalletAccount(address) {
+    return new Promise(resolve => {
+      if (address) {
+        accountsObservable.subject.subscribe(storedAccounts => {
+          if (storedAccounts[address]) {
+            resolve(true);
+          }
+          resolve(false);
+        });
+      } else {
+        resolve(false);
+      }
+    });
+  }
+  accountsTie2({
+    address,
+    genesisHash
+  }) {
+    return this.#koniState.setAccountTie(address, genesisHash);
+  }
+  async accountsCreateExternalV2({
+    address,
+    genesisHash,
+    isAllowed,
+    isEthereum,
+    isReadOnly,
+    name
+  }) {
+    try {
+      let result;
+      try {
+        const exists = keyring.getPair(address);
+        if (exists) {
+          if (exists.type === (isEthereum ? 'ethereum' : 'sr25519')) {
+            return [{
+              code: AccountExternalErrorCode.INVALID_ADDRESS,
+              message: 'Account exists'
+            }];
+          }
+        }
+      } catch (e) {}
+      if (isEthereum) {
+        const chainInfoMap = this.#koniState.getChainInfoMap();
+        let _gen = '';
+        if (genesisHash) {
+          for (const network of Object.values(chainInfoMap)) {
+            if (_getEvmChainId(network) === parseInt(genesisHash)) {
+              // TODO: pure EVM chains do not have genesisHash
+              _gen = _getSubstrateGenesisHash(network);
+            }
+          }
+        }
+        result = keyring.keyring.addFromAddress(address, {
+          name,
+          isExternal: true,
+          isReadOnly,
+          genesisHash: _gen
+        }, null, 'ethereum');
+        keyring.saveAccount(result);
+      } else {
+        result = keyring.addExternal(address, {
+          genesisHash,
+          name,
+          isReadOnly
+        }).pair;
+      }
+      const _address = result.address;
+      await new Promise(resolve => {
+        this.#koniState.addAccountRef([_address], () => {
+          resolve();
+        });
+      });
+      await new Promise(resolve => {
+        this._saveCurrentAccountAddress(_address, () => {
+          this._addAddressToAuthList(_address, isAllowed);
+          resolve();
+        });
+      });
+      return [];
+    } catch (e) {
+      return [{
+        code: AccountExternalErrorCode.KEYRING_ERROR,
+        message: e.message
+      }];
+    }
+  }
+  async accountsCreateHardwareV2({
+    accountIndex,
+    address,
+    addressOffset,
+    genesisHash,
+    hardwareType,
+    isAllowed,
+    name
+  }) {
+    const key = keyring.addHardware(address, hardwareType, {
+      accountIndex,
+      addressOffset,
+      genesisHash,
+      name,
+      originGenesisHash: genesisHash
+    });
+    const result = key.pair;
+    const _address = result.address;
+    await new Promise(resolve => {
+      this.#koniState.addAccountRef([_address], () => {
+        resolve();
+      });
+    });
+    await new Promise(resolve => {
+      this._saveCurrentAccountAddress(_address, () => {
+        this._addAddressToAuthList(_address, isAllowed || false);
+        resolve();
+      });
+    });
+    return true;
+  }
+  async accountsCreateHardwareMultiple({
+    accounts
+  }) {
+    const addresses = [];
+    if (!accounts.length) {
+      throw new Error('No accounts to import');
+    }
+    for (const account of accounts) {
+      const {
+        accountIndex,
+        address,
+        addressOffset,
+        genesisHash,
+        hardwareType,
+        name
+      } = account;
+      const key = keyring.addHardware(address, hardwareType, {
+        accountIndex,
+        addressOffset,
+        genesisHash,
+        name,
+        originGenesisHash: genesisHash
+      });
+      const result = key.pair;
+      const _address = result.address;
+      addresses.push(_address);
+      await new Promise(resolve => {
+        this._addAddressToAuthList(_address, true);
+        resolve();
+      });
+    }
+    const currentAccount = await new Promise(resolve => {
+      this.#koniState.getCurrentAccount(resolve);
+    });
+    const allGenesisHash = (currentAccount === null || currentAccount === void 0 ? void 0 : currentAccount.allGenesisHash) || undefined;
+    if (addresses.length <= 1) {
+      this.#koniState.setCurrentAccount({
+        address: addresses[0],
+        currentGenesisHash: null,
+        allGenesisHash
+      });
+    } else {
+      this.#koniState.setCurrentAccount({
+        address: ALL_ACCOUNT_KEY,
+        currentGenesisHash: allGenesisHash || null,
+        allGenesisHash
+      });
+    }
+    await new Promise(resolve => {
+      this.#koniState.addAccountRef(addresses, () => {
+        resolve();
+      });
+    });
+    return true;
+  }
+  async accountsCreateWithSecret({
+    isAllow,
+    isEthereum,
+    name,
+    publicKey,
+    secretKey
+  }) {
+    try {
+      let keyringPair = null;
+      if (isEthereum) {
+        const _secret = hexStripPrefix(secretKey);
+        if (_secret.length === 64) {
+          const suri = `0x${_secret}`;
+          const {
+            phrase
+          } = keyExtractSuri(suri);
+          if (isHex(phrase) && isHex(phrase, 256)) {
+            const type = 'ethereum';
+            keyringPair = keyring.addUri(getSuri(suri, type), {
+              name: name
+            }, type).pair;
+          }
+        }
+      } else {
+        keyringPair = keyring.keyring.addFromPair({
+          publicKey: hexToU8a(publicKey),
+          secretKey: hexToU8a(secretKey)
+        }, {
+          name
+        });
+        keyring.addPair(keyringPair, true);
+      }
+      if (!keyringPair) {
+        return {
+          success: false,
+          errors: [{
+            code: AccountExternalErrorCode.KEYRING_ERROR,
+            message: 'Invalid keyring'
+          }]
+        };
+      }
+      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();
+        });
+      });
+      return {
+        errors: [],
+        success: true
+      };
+    } catch (e) {
+      return {
+        success: false,
+        errors: [{
+          code: AccountExternalErrorCode.KEYRING_ERROR,
+          message: e.message
+        }]
+      };
+    }
+  }
+
+  /// External account
+
+  rejectExternalRequest(request) {
+    const {
+      id,
+      message,
+      throwError
+    } = request;
+    const promise = this.#koniState.getExternalRequest(id);
+    if (promise.status === ExternalRequestPromiseStatus.PENDING && promise.reject) {
+      if (throwError) {
+        promise.reject(new Error(message));
+      } else {
+        promise.reject();
+      }
+      this.#koniState.updateExternalRequest(id, {
+        status: ExternalRequestPromiseStatus.REJECTED,
+        message: message,
+        reject: undefined,
+        resolve: undefined
+      });
+    }
+  }
+  resolveQrTransfer(request) {
+    const {
+      data,
+      id
+    } = request;
+    const promise = this.#koniState.getExternalRequest(id);
+    if (promise.status === ExternalRequestPromiseStatus.PENDING) {
+      promise.resolve && promise.resolve(data);
+      this.#koniState.updateExternalRequest(id, {
+        status: ExternalRequestPromiseStatus.COMPLETED,
+        reject: undefined,
+        resolve: undefined
+      });
+    }
+  }
+  subscribeConfirmations(id, port) {
+    const cb = createSubscription(id, port);
+    const subscription = this.#koniState.getConfirmationsQueueSubject().subscribe(cb);
+    this.createUnsubscriptionHandle(id, subscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return this.#koniState.getConfirmationsQueueSubject().getValue();
+  }
+  async completeConfirmation(request) {
+    return await this.#koniState.completeConfirmation(request);
+  }
+
+  /// Sign Qr
+
+  getNetworkJsonByChainId(chainId) {
+    const chainInfoMap = this.#koniState.getChainInfoMap();
+    if (!chainId) {
+      for (const n in chainInfoMap) {
+        if (!Object.prototype.hasOwnProperty.call(chainInfoMap, n)) {
+          continue;
+        }
+        const networkInfo = chainInfoMap[n];
+        if (_isChainEvmCompatible(networkInfo)) {
+          return networkInfo;
+        }
+      }
+      return null;
+    }
+    for (const n in chainInfoMap) {
+      if (!Object.prototype.hasOwnProperty.call(chainInfoMap, n)) {
+        continue;
+      }
+      const networkInfo = chainInfoMap[n];
+      if (_getEvmChainId(networkInfo) === chainId) {
+        return networkInfo;
+      }
+    }
+    return null;
+  }
+
+  // Parse transaction
+
+  parseSubstrateTransaction({
+    data,
+    networkKey
+  }) {
+    const apiProps = this.#koniState.getSubstrateApi(networkKey);
+    const apiPromise = apiProps.api;
+    return parseSubstrateTransaction(data, apiPromise);
+  }
+  async parseEVMRLP({
+    data
+  }) {
+    return await parseEvmRlp(data, this.#koniState.getChainInfoMap(), this.#koniState.getEvmApiMap());
+  }
+
+  // Sign
+
+  qrSignSubstrate({
+    address,
+    data,
+    networkKey
+  }) {
+    const pair = keyring.getPair(address);
+    assert(pair, 'Unable to find pair');
+    if (pair.isLocked) {
+      keyring.unlockPair(pair.address);
+    }
+    let signed = hexStripPrefix(u8aToHex(pair.sign(data, {
+      withType: true
+    })));
+    const network = this.#koniState.getChainInfo(networkKey);
+    if (_isChainEvmCompatible(network)) {
+      signed = signed.substring(2);
+    }
+    return {
+      signature: signed
+    };
+  }
+  async qrSignEVM({
+    address,
+    chainId,
+    message,
+    type
+  }) {
+    let signed;
+    const network = this.getNetworkJsonByChainId(chainId);
+    if (!network) {
+      throw new Error('Cannot find network');
+    }
+    const pair = keyring.getPair(address);
+    if (!pair) {
+      throw Error('Unable to find pair');
+    }
+    if (pair.isLocked) {
+      keyring.unlockPair(pair.address);
+    }
+    if (type === 'message') {
+      let data = message;
+      if (isHex(message)) {
+        data = message;
+      } else if (isAscii(message)) {
+        data = `0x${message}`;
+      }
+      signed = await pair.evmSigner.signMessage(data, 'personal_sign');
+    } else {
+      const tx = createTransactionFromRLP(message);
+      if (!tx) {
+        throw new Error(`Cannot create tx from ${message}`);
+      }
+      const txObject = {
+        gasPrice: new BigN(tx.gasPrice).toNumber(),
+        to: tx.action,
+        value: new BigN(tx.value).toNumber(),
+        data: tx.data,
+        nonce: new BigN(tx.nonce).toNumber(),
+        gas: new BigN(tx.gas).toNumber()
+      };
+      const common = Common.forCustomChain('mainnet', {
+        name: network.name,
+        networkId: _getEvmChainId(network),
+        chainId: _getEvmChainId(network)
+      }, 'petersburg');
+
+      // @ts-ignore
+      const transaction = new Transaction(txObject, {
+        common
+      });
+      pair.evmSigner.signTransaction(transaction);
+      signed = signatureToHex({
+        r: u8aToHex(transaction.r),
+        s: u8aToHex(transaction.s),
+        v: u8aToHex(transaction.v)
+      });
+    }
+    return {
+      signature: hexStripPrefix(signed)
+    };
+  }
+  async subscribeChainStakingMetadata(id, port) {
+    const cb = createSubscription(id, port);
+    const chainStakingMetadata = this.#koniState.subscribeChainStakingMetadata().subscribe({
+      next: rs => {
+        cb(rs);
+      }
+    });
+    this.createUnsubscriptionHandle(id, chainStakingMetadata.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return this.#koniState.getChainStakingMetadata();
+  }
+  async subscribeStakingNominatorMetadata(id, port) {
+    const cb = createSubscription(id, port);
+    const nominatorMetadata = this.#koniState.subscribeNominatorMetadata().subscribe({
+      next: rs => {
+        cb(rs);
+      }
+    });
+    this.createUnsubscriptionHandle(id, nominatorMetadata.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return this.#koniState.getNominatorMetadata();
+  }
+  async getBondingOptions({
+    chain,
+    type
+  }) {
+    const apiProps = this.#koniState.getSubstrateApi(chain);
+    const chainInfo = this.#koniState.getChainInfo(chain);
+    const chainStakingMetadata = await this.#koniState.getStakingMetadataByChain(chain, type);
+    if (!chainStakingMetadata) {
+      return;
+    }
+    const {
+      decimals
+    } = _getChainNativeTokenBasicInfo(chainInfo);
+    return await getValidatorsInfo(chain, apiProps, decimals, chainStakingMetadata);
+  }
+  async getNominationPoolOptions(chain) {
+    const substrateApi = this.#koniState.getSubstrateApi(chain);
+    return await getNominationPoolsInfo(chain, substrateApi);
+  }
+  async submitBonding(inputData) {
+    const {
+      amount,
+      chain,
+      nominatorMetadata,
+      selectedValidators
+    } = inputData;
+    if (!amount || !nominatorMetadata || !selectedValidators) {
+      // Todo: Check and return error here
+
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new TransactionError(BasicTxErrorType.INVALID_PARAMS)]);
+    }
+    const chainInfo = this.#koniState.getChainInfo(chain);
+    const substrateApi = this.#koniState.getSubstrateApi(chain);
+    const extrinsic = await getBondingExtrinsic(chainInfo, amount, nominatorMetadata, selectedValidators, substrateApi);
+    return await this.#koniState.transactionService.handleTransaction({
+      address: nominatorMetadata.address,
+      chain: chain,
+      chainType: ChainType.SUBSTRATE,
+      data: inputData,
+      extrinsicType: ExtrinsicType.STAKING_BOND,
+      transaction: extrinsic,
+      url: EXTENSION_REQUEST_URL
+    });
+  }
+  async submitUnbonding(inputData) {
+    const {
+      amount,
+      chain,
+      nominatorMetadata,
+      validatorAddress
+    } = inputData;
+    if (!amount || !nominatorMetadata) {
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new TransactionError(BasicTxErrorType.INVALID_PARAMS)]);
+    }
+    const substrateApi = this.#koniState.getSubstrateApi(chain);
+    const extrinsic = await getUnbondingExtrinsic(nominatorMetadata, amount, chain, substrateApi, validatorAddress);
+    return await this.#koniState.transactionService.handleTransaction({
+      address: nominatorMetadata.address,
+      chain: chain,
+      transaction: extrinsic,
+      data: inputData,
+      extrinsicType: ExtrinsicType.STAKING_UNBOND,
+      chainType: ChainType.SUBSTRATE
+    });
+  }
+  async submitStakeWithdrawal(inputData) {
+    const {
+      chain,
+      nominatorMetadata,
+      validatorAddress
+    } = inputData;
+    if (!nominatorMetadata) {
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new TransactionError(BasicTxErrorType.INVALID_PARAMS)]);
+    }
+    const dotSamaApi = this.#koniState.getSubstrateApi(chain);
+    const extrinsic = await getWithdrawalExtrinsic(dotSamaApi, chain, nominatorMetadata, validatorAddress);
+    return await this.#koniState.transactionService.handleTransaction({
+      address: nominatorMetadata.address,
+      chain: chain,
+      transaction: extrinsic,
+      data: inputData,
+      extrinsicType: ExtrinsicType.STAKING_WITHDRAW,
+      chainType: ChainType.SUBSTRATE
+    });
+  }
+  async submitStakeClaimReward(inputData) {
+    const {
+      address,
+      chain,
+      stakingType,
+      validatorAddress
+    } = inputData;
+    if (!address) {
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new TransactionError(BasicTxErrorType.INVALID_PARAMS)]);
+    }
+    const substrateApi = this.#koniState.getSubstrateApi(chain);
+    const extrinsic = await getClaimRewardExtrinsic(substrateApi, chain, address, stakingType, validatorAddress);
+    return await this.#koniState.transactionService.handleTransaction({
+      address,
+      chain: chain,
+      transaction: extrinsic,
+      data: inputData,
+      extrinsicType: ExtrinsicType.STAKING_CLAIM_REWARD,
+      chainType: ChainType.SUBSTRATE
+    });
+  }
+  async submitCancelStakeWithdrawal(inputData) {
+    const {
+      address,
+      chain,
+      selectedUnstaking
+    } = inputData;
+    if (!chain || !selectedUnstaking) {
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new TransactionError(BasicTxErrorType.INVALID_PARAMS)]);
+    }
+    const substrateApi = this.#koniState.getSubstrateApi(chain);
+    const extrinsic = await getCancelWithdrawalExtrinsic(substrateApi, chain, selectedUnstaking);
+    return await this.#koniState.transactionService.handleTransaction({
+      address,
+      chain,
+      transaction: extrinsic,
+      data: inputData,
+      extrinsicType: ExtrinsicType.STAKING_CANCEL_WITHDRAWAL,
+      chainType: ChainType.SUBSTRATE
+    });
+  }
+  async submitPoolingBonding(inputData) {
+    const {
+      address,
+      amount,
+      chain,
+      nominatorMetadata,
+      selectedPool
+    } = inputData;
+    const substrateApi = this.#koniState.getSubstrateApi(chain);
+    const extrinsic = await getPoolingBondingExtrinsic(substrateApi, amount, selectedPool.id, nominatorMetadata);
+    return await this.#koniState.transactionService.handleTransaction({
+      address,
+      chain,
+      transaction: extrinsic,
+      data: inputData,
+      extrinsicType: ExtrinsicType.STAKING_BOND,
+      chainType: ChainType.SUBSTRATE
+    });
+  }
+  async submitPoolingUnbonding(inputData) {
+    const {
+      amount,
+      chain,
+      nominatorMetadata
+    } = inputData;
+    const substrateApi = this.#koniState.getSubstrateApi(chain);
+    const extrinsic = await getPoolingUnbondingExtrinsic(substrateApi, amount, nominatorMetadata);
+    return await this.#koniState.transactionService.handleTransaction({
+      address: nominatorMetadata.address,
+      chain,
+      transaction: extrinsic,
+      data: inputData,
+      extrinsicType: ExtrinsicType.STAKING_UNBOND,
+      chainType: ChainType.SUBSTRATE
+    });
+  }
+  async submitPoolingWithdrawal(inputData) {
+    const {
+      chain,
+      isReBond,
+      nominatorMetadata
+    } = inputData;
+    const substrateApi = this.#koniState.getSubstrateApi(chain);
+    const extrinsic = await getPoolingWithdrawalExtrinsic(substrateApi, nominatorMetadata, isReBond);
+    return await this.#koniState.transactionService.handleTransaction({
+      address: nominatorMetadata.address,
+      chain,
+      transaction: extrinsic,
+      data: inputData,
+      extrinsicType: ExtrinsicType.STAKING_WITHDRAW,
+      chainType: ChainType.SUBSTRATE
+    });
+  }
+
+  // EVM Transaction
+  async parseContractInput({
+    chainId,
+    contract,
+    data
+  }) {
+    const network = this.getNetworkJsonByChainId(chainId);
+    return await parseContractInput(data, contract, network);
+  }
+  async submitTuringStakeCompounding(inputData) {
+    const {
+      accountMinimum,
+      address,
+      bondedAmount,
+      collatorAddress,
+      networkKey
+    } = inputData;
+    if (!address) {
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new TransactionError(BasicTxErrorType.INVALID_PARAMS)]);
+    }
+    const dotSamaApi = this.#koniState.getSubstrateApi(networkKey);
+    const chainInfo = this.#koniState.getChainInfo(networkKey);
+    const {
+      decimals
+    } = _getChainNativeTokenBasicInfo(chainInfo);
+    const parsedAccountMinimum = parseFloat(accountMinimum) * 10 ** decimals;
+    const extrinsic = await getTuringCompoundExtrinsic(dotSamaApi, address, collatorAddress, parsedAccountMinimum.toString(), bondedAmount);
+    return await this.#koniState.transactionService.handleTransaction({
+      address,
+      chain: networkKey,
+      transaction: extrinsic,
+      data: inputData,
+      extrinsicType: ExtrinsicType.STAKING_COMPOUNDING,
+      chainType: ChainType.SUBSTRATE
+    });
+  }
+  async submitTuringCancelStakeCompound(inputData) {
+    const {
+      address,
+      networkKey,
+      taskId
+    } = inputData;
+    const txState = {};
+    if (!address) {
+      txState.txError = true;
+      return txState;
+    }
+    const dotSamaApi = this.#koniState.getSubstrateApi(networkKey);
+    const extrinsic = await getTuringCancelCompoundingExtrinsic(dotSamaApi, taskId);
+    return await this.#koniState.transactionService.handleTransaction({
+      address,
+      chain: networkKey,
+      transaction: extrinsic,
+      data: inputData,
+      extrinsicType: ExtrinsicType.STAKING_CANCEL_COMPOUNDING,
+      chainType: ChainType.SUBSTRATE
+    });
+  }
+  async wasmNftGetTransaction({
+    networkKey,
+    params,
+    recipientAddress,
+    senderAddress
+  }) {
+    const contractAddress = params.contractAddress;
+    const onChainOption = params.onChainOption;
+    try {
+      return await getPSP34Transaction(this.#koniState.getEvmApiMap(), this.#koniState.getSubstrateApiMap(), this.#koniState.getChainInfo(networkKey), networkKey, contractAddress, senderAddress, recipientAddress, onChainOption);
+    } catch (e) {
+      console.error('Error getting WASM NFT transaction', e);
+      return {
+        error: true,
+        balanceError: false
+      };
+    }
+  }
+  keyringStateSubscribe(id, port) {
+    const cb = createSubscription(id, port);
+    const subscription = this.#koniState.subscribeKeyringState().subscribe(value => cb(value));
+    this.createUnsubscriptionHandle(id, subscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return this.#koniState.getKeyringState();
+  }
+  keyringChangeMasterPassword({
+    createNew,
+    newPassword,
+    oldPassword
+  }) {
+    try {
+      // Remove isMasterPassword meta if createNew
+      if (createNew) {
+        const pairs = keyring.getPairs();
+        for (const pair of pairs) {
+          const meta = {
+            ...pair.meta,
+            isMasterPassword: false
+          };
+          if (!meta.originGenesisHash) {
+            meta.genesisHash = '';
+          }
+          pair.setMeta(meta);
+          keyring.saveAccountMeta(pair, pair.meta);
+        }
+      }
+      keyring.changeMasterPassword(newPassword, oldPassword);
+    } catch (e) {
+      console.error(e);
+      return {
+        errors: [e.message],
+        status: false
+      };
+    }
+    this.#koniState.setKeyringState({
+      hasMasterPassword: true,
+      isLocked: false,
+      isReady: true
+    });
+    return {
+      status: true,
+      errors: []
+    };
+  }
+  keyringMigrateMasterPassword({
+    address,
+    password
+  }) {
+    try {
+      keyring.migrateWithMasterPassword(address, password);
+    } catch (e) {
+      console.error(e);
+      return {
+        errors: [e.message],
+        status: false
+      };
+    }
+    return {
+      status: true,
+      errors: []
+    };
+  }
+  keyringUnlock({
+    password
+  }) {
+    try {
+      keyring.unlockKeyring(password);
+    } catch (e) {
+      return {
+        errors: [e.message],
+        status: false
+      };
+    }
+    this.#koniState.setKeyringState({
+      isReady: true,
+      hasMasterPassword: true,
+      isLocked: false
+    });
+    return {
+      status: true,
+      errors: []
+    };
+  }
+  keyringLock() {
+    keyring.lockAll();
+    this.#koniState.setKeyringState({
+      isReady: true,
+      hasMasterPassword: true,
+      isLocked: true
+    });
+  }
+  keyringExportMnemonic({
+    address,
+    password
+  }) {
+    const pair = keyring.getPair(address);
+    const result = pair.exportMnemonic(password);
+    return {
+      result
+    };
+  }
+
+  /// Signing external request
+  signingApprovePasswordV2({
+    id
+  }) {
+    const queued = this.#koniState.getSignRequest(id);
+    assert(queued, 'Unable to find request');
+    const {
+      reject,
+      request,
+      resolve
+    } = queued;
+    const pair = keyring.getPair(queued.account.address);
+
+    // unlike queued.account.address the following
+    // address is encoded with the default prefix
+    // which what is used for password caching mapping
+    const {
+      address
+    } = pair;
+    if (!pair) {
+      reject(new Error('Unable to find pair'));
+      return false;
+    }
+    if (pair.isLocked) {
+      keyring.unlockPair(address);
+    }
+    const {
+      payload
+    } = request;
+    const registry = new TypeRegistry();
+    if (isJsonPayload(payload)) {
+      // Get the metadata for the genesisHash
+      const currentMetadata = this.#koniState.knownMetadata.find(meta => meta.genesisHash === payload.genesisHash);
+
+      // set the registry before calling the sign function
+      registry.setSignedExtensions(payload.signedExtensions, currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.userExtensions);
+      if (currentMetadata) {
+        registry.register(currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.types);
+      }
+    }
+    const result = request.sign(registry, pair);
+    resolve({
+      id,
+      ...result
+    });
+    return true;
+  }
+
+  /// Derive account
+
+  derivationCreateMultiple({
+    isAllowed,
+    items,
+    parentAddress
+  }) {
+    const parentPair = keyring.getPair(parentAddress);
+    const isEvm = parentPair.type === 'ethereum';
+    if (parentPair.isLocked) {
+      keyring.unlockPair(parentPair.address);
+    }
+    const createChild = ({
+      name,
+      suri
+    }) => {
+      const meta = {
+        name: name,
+        parentAddress
+      };
+      if (isEvm) {
+        let index = 0;
+        try {
+          const reg = /^\d+$/;
+          const path = suri.split('//')[1];
+          if (reg.test(path)) {
+            index = parseInt(path);
+          }
+        } catch (e) {}
+        if (!index) {
+          throw Error('Invalid derive path');
+        }
+        meta.suri = `//${index}`;
+        return parentPair.deriveEvm(index, meta);
+      } else {
+        meta.suri = suri;
+        return parentPair.derive(suri, meta);
+      }
+    };
+    const result = [];
+    for (const item of items) {
+      try {
+        const childPair = createChild(item);
+        const address = childPair.address;
+        keyring.addPair(childPair, true);
+        this._addAddressToAuthList(address, isAllowed);
+        result.push(childPair);
+      } catch (e) {
+        console.log(`Fail to derive from ${parentAddress} with path ${item.suri}`, e);
+      }
+    }
+    if (result.length === 1) {
+      this._saveCurrentAccountAddress(result[0].address);
+    } else {
+      this.#koniState.setCurrentAccount({
+        address: ALL_ACCOUNT_KEY,
+        currentGenesisHash: null
+      });
+    }
+    return true;
+  }
+  derivationCreateV3({
+    address: parentAddress
+  }) {
+    const parentPair = keyring.getPair(parentAddress);
+    const isEvm = parentPair.type === 'ethereum';
+    if (parentPair.isLocked) {
+      keyring.unlockPair(parentPair.address);
+    }
+    const pairs = keyring.getPairs();
+    const children = pairs.filter(p => p.meta.parentAddress === parentAddress);
+    const name = `Account ${pairs.length}`;
+    let index = isEvm ? 1 : 0;
+    let valid = false;
+    do {
+      const exist = children.find(p => p.meta.suri === `//${index}`);
+      if (exist) {
+        index++;
+      } else {
+        valid = true;
+      }
+    } while (!valid);
+    const meta = {
+      name,
+      parentAddress,
+      suri: `//${index}`
+    };
+    const childPair = isEvm ? parentPair.deriveEvm(index, meta) : parentPair.derive(meta.suri, meta);
+    const address = childPair.address;
+    this._saveCurrentAccountAddress(address, () => {
+      keyring.addPair(childPair, true);
+      this._addAddressToAuthList(address, true);
+    });
+    return true;
+  }
+  validateDerivePath({
+    parentAddress,
+    suri
+  }) {
+    const parentPair = keyring.getPair(parentAddress);
+    const isEvm = parentPair.type === 'ethereum';
+    if (parentPair.isLocked) {
+      keyring.unlockPair(parentPair.address);
+    }
+    const meta = {
+      parentAddress
+    };
+    let childPair;
+    if (isEvm) {
+      let index = 0;
+      try {
+        const reg = /^\d+$/;
+        const path = suri.split('//')[1];
+        if (reg.test(path)) {
+          index = parseInt(path);
+        }
+      } catch (e) {}
+      if (!index) {
+        throw Error('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
+    };
+  }
+  getListDeriveAccounts({
+    limit,
+    page,
+    parentAddress
+  }) {
+    const parentPair = keyring.getPair(parentAddress);
+    const isEvm = parentPair.type === 'ethereum';
+    if (parentPair.isLocked) {
+      keyring.unlockPair(parentPair.address);
+    }
+    const start = (page - 1) * limit + (isEvm ? 1 : 0);
+    const end = start + limit;
+    const result = [];
+    for (let i = start; i < end; i++) {
+      const suri = `//${i}`;
+      const pair = isEvm ? parentPair.deriveEvm(i, {}) : parentPair.derive(suri, {});
+      result.push({
+        address: pair.address,
+        suri: suri
+      });
+    }
+    return {
+      result: result
+    };
+  }
+
+  // ChainService -------------------------------------------------
+  subscribeChainInfoMap(id, port) {
+    const cb = createSubscription(id, port);
+    const chainInfoMapSubscription = this.#koniState.subscribeChainInfoMap().subscribe({
+      next: rs => {
+        cb(rs);
+      }
+    });
+    this.createUnsubscriptionHandle(id, chainInfoMapSubscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return this.#koniState.getChainInfoMap();
+  }
+  subscribeChainStateMap(id, port) {
+    const cb = createSubscription(id, port);
+    const chainStateMapSubscription = this.#koniState.subscribeChainStateMap().subscribe({
+      next: rs => {
+        cb(rs);
+      }
+    });
+    this.createUnsubscriptionHandle(id, chainStateMapSubscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return this.#koniState.getChainStateMap();
+  }
+  subscribeAssetRegistry(id, port) {
+    const cb = createSubscription(id, port);
+    const assetRegistrySubscription = this.#koniState.subscribeAssetRegistry().subscribe({
+      next: rs => {
+        cb(rs);
+      }
+    });
+    this.createUnsubscriptionHandle(id, assetRegistrySubscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return this.#koniState.getAssetRegistry();
+  }
+  subscribeMultiChainAssetMap(id, port) {
+    const cb = createSubscription(id, port);
+    const multiChainAssetSubscription = this.#koniState.subscribeMultiChainAssetMap().subscribe({
+      next: rs => {
+        cb(rs);
+      }
+    });
+    this.createUnsubscriptionHandle(id, multiChainAssetSubscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return this.#koniState.getMultiChainAssetMap();
+  }
+  getSupportedSmartContractTypes() {
+    return this.#koniState.getSupportedSmartContractTypes();
+  }
+  getTransaction({
+    id
+  }) {
+    const {
+      transaction,
+      ...transactionResult
+    } = this.#koniState.transactionService.getTransaction(id);
+    return transactionResult;
+  }
+  subscribeTransactions(id, port) {
+    const cb = createSubscription(id, port);
+    function convertRs(rs) {
+      return Object.fromEntries(Object.entries(rs).map(([key, value]) => {
+        const {
+          transaction,
+          ...transactionResult
+        } = value;
+        return [key, transactionResult];
+      }));
+    }
+    const transactionsSubject = this.#koniState.transactionService.getTransactionSubject();
+    const transactionsSubscription = transactionsSubject.subscribe(rs => {
+      cb(convertRs(rs));
+    });
+    port.onDisconnect.addListener(() => {
+      transactionsSubscription.unsubscribe();
+      this.cancelSubscription(id);
+    });
+    return convertRs(transactionsSubject.getValue());
+  }
+
+  // --------------------------------------------------------------
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async handle(id, type, request, port) {
+    switch (type) {
+      /// 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.edit)':
+        return this.accountsEdit(request);
+      case 'pri(accounts.export)':
+        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)':
+        return this.metadataGet(request);
+      case 'pri(metadata.list)':
+        return this.metadataList();
+      case 'pri(metadata.reject)':
+        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(settings.notification)':
+        return this.#koniState.setNotification(request);
+      case 'pri(signing.approve.signature)':
+        return this.signingApproveSignature(request);
+      case 'pri(signing.cancel)':
+        return this.signingCancel(request);
+      case 'pri(signing.requests)':
+        return this.signingSubscribe(id, port);
+      case 'pri(window.open)':
+        return this.windowOpen(request);
+
+      ///
+      case 'pri(authorize.changeSiteAll)':
+        return this.changeAuthorizationAll(request, id, port);
+      case 'pri(authorize.changeSite)':
+        return this.changeAuthorization(request, id, port);
+      case 'pri(authorize.changeSitePerAccount)':
+        return this.changeAuthorizationPerAcc(request, id, port);
+      case 'pri(authorize.changeSitePerSite)':
+        return this.changeAuthorizationPerSite(request);
+      case 'pri(authorize.changeSiteBlock)':
+        return this.changeAuthorizationBlock(request);
+      case 'pri(authorize.forgetSite)':
+        return this.forgetSite(request, id, port);
+      case 'pri(authorize.forgetAllSite)':
+        return this.forgetAllSite(id, port);
+      case 'pri(authorize.approveV2)':
+        return this.authorizeApproveV2(request);
+      case 'pri(authorize.rejectV2)':
+        return this.authorizeRejectV2(request);
+      case 'pri(authorize.cancelV2)':
+        return this.authorizeCancelV2(request);
+      case 'pri(authorize.requestsV2)':
+        return this.authorizeSubscribeV2(id, port);
+      case 'pri(authorize.listV2)':
+        return this.getAuthListV2();
+      case 'pri(authorize.toggle)':
+        return this.toggleAuthorization2(request);
+      case 'pri(accounts.create.suriV2)':
+        return await this.accountsCreateSuriV2(request);
+      case 'pri(accounts.forget)':
+        return await this.accountsForgetOverride(request);
+      case 'pri(accounts.create.externalV2)':
+        return await this.accountsCreateExternalV2(request);
+      case 'pri(accounts.create.hardwareV2)':
+        return await this.accountsCreateHardwareV2(request);
+      case 'pri(accounts.create.hardwareMultiple)':
+        return await this.accountsCreateHardwareMultiple(request);
+      case 'pri(accounts.create.withSecret)':
+        return await this.accountsCreateWithSecret(request);
+      case 'pri(seed.createV2)':
+        return this.seedCreateV2(request);
+      case 'pri(seed.validateV2)':
+        return this.seedValidateV2(request);
+      case 'pri(privateKey.validateV2)':
+        return this.metamaskPrivateKeyValidateV2(request);
+      case 'pri(accounts.exportPrivateKey)':
+        return this.accountExportPrivateKey(request);
+      case 'pri(accounts.checkPublicAndSecretKey)':
+        return this.checkPublicAndSecretKey(request);
+      case 'pri(accounts.subscribeWithCurrentAddress)':
+        return await this.accountsGetAllWithCurrentAddress(id, port);
+      case 'pri(accounts.subscribeAccountsInputAddress)':
+        return this.accountsGetAll(id, port);
+      case 'pri(accounts.saveRecent)':
+        return this.saveRecentAccountId(request);
+      case 'pri(accounts.triggerSubscription)':
+        return this.triggerAccountsSubscription();
+      case 'pri(currentAccount.saveAddress)':
+        return this.saveCurrentAccountAddress(request, id, port);
+      case 'pri(accounts.updateCurrentAddress)':
+        return this.updateCurrentAccountAddress(request);
+      case 'pri(settings.changeBalancesVisibility)':
+        return this.toggleBalancesVisibility(id, port);
+      case 'pri(settings.subscribe)':
+        return await this.subscribeSettings(id, port);
+      case 'pri(settings.saveAccountAllLogo)':
+        return this.saveAccountAllLogo(request, id, port);
+      case 'pri(settings.saveTheme)':
+        return this.saveTheme(request, id, port);
+      case 'pri(settings.saveBrowserConfirmationType)':
+        return this.saveBrowserConfirmationType(request, id, port);
+      case 'pri(price.getPrice)':
+        return await this.getPrice();
+      case 'pri(price.getSubscription)':
+        return await this.subscribePrice(id, port);
+      case 'pri(balance.getBalance)':
+        return this.getBalance();
+      case 'pri(balance.getSubscription)':
+        return this.subscribeBalance(id, port);
+      case 'pri(crowdloan.getCrowdloan)':
+        return this.getCrowdloan();
+      case 'pri(crowdloan.getSubscription)':
+        return this.subscribeCrowdloan(id, port);
+      case 'pri(derivation.createV2)':
+        return this.derivationCreateV2(request);
+      case 'pri(json.restoreV2)':
+        return this.jsonRestoreV2(request);
+      case 'pri(json.batchRestoreV2)':
+        return this.batchRestoreV2(request);
+      case 'pri(nft.getNft)':
+        return await this.getNft();
+      case 'pri(nft.getSubscription)':
+        return await this.subscribeNft(id, port);
+      case 'pri(nftCollection.getNftCollection)':
+        return await this.getNftCollection();
+      case 'pri(nftCollection.getSubscription)':
+        return await this.subscribeNftCollection(id, port);
+      case 'pri(staking.getStaking)':
+        return this.getStaking();
+      case 'pri(staking.getSubscription)':
+        return await this.subscribeStaking(id, port);
+      case 'pri(stakingReward.getStakingReward)':
+        return this.getStakingReward();
+      case 'pri(stakingReward.getSubscription)':
+        return this.subscribeStakingReward(id, port);
+      case 'pri(transaction.history.getSubscription)':
+        return await this.subscribeHistory(id, port);
+
+      // ChainService
+      case 'pri(chainService.subscribeChainInfoMap)':
+        return this.subscribeChainInfoMap(id, port);
+      case 'pri(chainService.subscribeChainStateMap)':
+        return this.subscribeChainStateMap(id, port);
+      case 'pri(chainService.getSupportedContractTypes)':
+        return this.getSupportedSmartContractTypes();
+      case 'pri(chainService.enableChain)':
+        return this.enableChain(request);
+      case 'pri(chainService.disableChain)':
+        return this.disableChain(request);
+      case 'pri(chainService.removeChain)':
+        return this.removeCustomChain(request);
+      case 'pri(chainService.validateCustomChain)':
+        return await this.validateNetwork(request);
+      case 'pri(chainService.upsertChain)':
+        return this.upsertChain(request);
+      case 'pri(chainService.resetDefaultChains)':
+        return this.resetDefaultNetwork();
+      case 'pri(chainService.enableChains)':
+        return this.enableChains(request);
+      case 'pri(chainService.subscribeAssetRegistry)':
+        return this.subscribeAssetRegistry(id, port);
+      case 'pri(chainService.subscribeMultiChainAssetMap)':
+        return this.subscribeMultiChainAssetMap(id, port);
+      case 'pri(chainService.upsertCustomAsset)':
+        return this.upsertCustomToken(request);
+      case 'pri(chainService.deleteCustomAsset)':
+        return this.deleteCustomAsset(request);
+      case 'pri(chainService.validateCustomAsset)':
+        return await this.validateCustomAsset(request);
+      case 'pri(assetSetting.getSubscription)':
+        return this.subscribeAssetSetting(id, port);
+      case 'pri(assetSetting.update)':
+        return this.updateAssetSetting(request);
+      case 'pri(transfer.checkReferenceCount)':
+        return await this.transferCheckReferenceCount(request);
+      case 'pri(transfer.checkSupporting)':
+        return await this.transferCheckSupporting(request);
+      case 'pri(transfer.getExistentialDeposit)':
+        return this.transferGetExistentialDeposit(request);
+      case 'pri(freeBalance.subscribe)':
+        return this.subscribeAddressFreeBalance(request, id, port);
+      case 'pri(subscription.cancel)':
+        return this.cancelSubscription(request);
+      case 'pri(chainService.recoverSubstrateApi)':
+        return this.recoverDotSamaApi(request);
+      case 'pri(accounts.get.meta)':
+        return this.getAccountMeta(request);
+
+      /// Nft
+      case 'pri(nft.forceUpdate)':
+        return this.forceUpdateNftState(request);
+      case 'pri(nftTransfer.getNftTransfer)':
+        return this.getNftTransfer();
+      case 'pri(nftTransfer.getSubscription)':
+        return this.subscribeNftTransfer(id, port);
+      case 'pri(nftTransfer.setNftTransfer)':
+        return this.setNftTransfer(request);
+
+      // Send NFT
+      case 'pri(evmNft.submitTransaction)':
+        return this.evmNftSubmitTransaction(request);
+      case 'pri(substrateNft.submitTransaction)':
+        return this.substrateNftSubmitTransaction(request);
+
+      /// Transfer
+      case 'pri(accounts.transfer)':
+        return await this.makeTransfer(request);
+      case 'pri(accounts.crossChainTransfer)':
+        return await this.makeCrossChainTransfer(request);
+
+      /// Sign QR
+      case 'pri(qr.transaction.parse.substrate)':
+        return this.parseSubstrateTransaction(request);
+      case 'pri(qr.transaction.parse.evm)':
+        return await this.parseEVMRLP(request);
+      case 'pri(qr.sign.substrate)':
+        return this.qrSignSubstrate(request);
+      case 'pri(qr.sign.evm)':
+        return await this.qrSignEVM(request);
+
+      /// External account request
+      case 'pri(account.external.reject)':
+        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(confirmations.complete)':
+        return await this.completeConfirmation(request);
+
+      /// Stake
+      case 'pri(bonding.getBondingOptions)':
+        return await this.getBondingOptions(request);
+      case 'pri(bonding.getNominationPoolOptions)':
+        return await this.getNominationPoolOptions(request);
+      case 'pri(bonding.subscribeChainStakingMetadata)':
+        return await this.subscribeChainStakingMetadata(id, port);
+      case 'pri(bonding.subscribeNominatorMetadata)':
+        return await this.subscribeStakingNominatorMetadata(id, port);
+      case 'pri(bonding.submitBondingTransaction)':
+        return await this.submitBonding(request);
+      case 'pri(unbonding.submitTransaction)':
+        return await this.submitUnbonding(request);
+      case 'pri(unbonding.submitWithdrawal)':
+        return await this.submitStakeWithdrawal(request);
+      case 'pri(staking.submitClaimReward)':
+        return await this.submitStakeClaimReward(request);
+      case 'pri(staking.submitCancelWithdrawal)':
+        return await this.submitCancelStakeWithdrawal(request);
+      case 'pri(staking.submitTuringCompound)':
+        return await this.submitTuringStakeCompounding(request);
+      case 'pri(staking.submitTuringCancelCompound)':
+        return await this.submitTuringCancelStakeCompound(request);
+      case 'pri(bonding.nominationPool.submitBonding)':
+        return await this.submitPoolingBonding(request);
+      case 'pri(bonding.nominationPool.submitUnbonding)':
+        return await this.submitPoolingUnbonding(request);
+      case 'pri(bonding.nominationPool.submitWithdrawal)':
+        return await this.submitPoolingWithdrawal(request);
+
+      // EVM Transaction
+      case 'pri(evm.transaction.parse.input)':
+        return await this.parseContractInput(request);
+
+      // Auth Url subscribe
+      case 'pri(authorize.subscribe)':
+        return await this.subscribeAuthUrls(id, port);
+      case 'pri(wasmNft.getTransaction)':
+        return await this.wasmNftGetTransaction(request);
+
+      /// Keyring state
+      case 'pri(keyring.subscribe)':
+        return this.keyringStateSubscribe(id, port);
+      case 'pri(keyring.change)':
+        return this.keyringChangeMasterPassword(request);
+      case 'pri(keyring.migrate)':
+        return this.keyringMigrateMasterPassword(request);
+      case 'pri(keyring.unlock)':
+        return this.keyringUnlock(request);
+      case 'pri(keyring.lock)':
+        return this.keyringLock();
+      case 'pri(keyring.export.mnemonic)':
+        return this.keyringExportMnemonic(request);
+
+      /// Signing external
+      case 'pri(signing.approve.passwordV2)':
+        return this.signingApprovePasswordV2(request);
+
+      /// Derive account
+      case 'pri(derivation.validateV2)':
+        return this.validateDerivePath(request);
+      case 'pri(derivation.getList)':
+        return this.getListDeriveAccounts(request);
+      case 'pri(derivation.create.multiple)':
+        return this.derivationCreateMultiple(request);
+      case 'pri(derivation.createV3)':
+        return this.derivationCreateV3(request);
+
+      // Transaction
+      case 'pri(transactions.getOne)':
+        return this.getTransaction(request);
+      case 'pri(transactions.subscribe)':
+        return this.subscribeTransactions(id, port);
+
+      // Default
+      default:
+        throw new Error(`Unable to handle message of type ${type}`);
+    }
+  }
+}