@subwallet/extension-base 0.8.4-0 → 1.0.1

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

@@ -0,0 +1,3092 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _common = _interopRequireDefault(require("@ethereumjs/common"));
+var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
+var _Extension = require("@subwallet/extension-base/background/handlers/Extension");
+var _helpers = require("@subwallet/extension-base/background/handlers/helpers");
+var _subscriptions = require("@subwallet/extension-base/background/handlers/subscriptions");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _constants = require("@subwallet/extension-base/constants");
+var _defaults = require("@subwallet/extension-base/defaults");
+var _parseTransaction = require("@subwallet/extension-base/koni/api/dotsama/parseTransaction");
+var _transfer = require("@subwallet/extension-base/koni/api/dotsama/transfer");
+var _transfer2 = require("@subwallet/extension-base/koni/api/nft/transfer");
+var _bonding = require("@subwallet/extension-base/koni/api/staking/bonding");
+var _paraChain = require("@subwallet/extension-base/koni/api/staking/bonding/paraChain");
+var _relayChain = require("@subwallet/extension-base/koni/api/staking/bonding/relayChain");
+var _transfer3 = require("@subwallet/extension-base/koni/api/tokens/evm/transfer");
+var _wasm = require("@subwallet/extension-base/koni/api/tokens/wasm");
+var _xcm = require("@subwallet/extension-base/koni/api/xcm");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _constants2 = require("@subwallet/extension-base/services/request-service/constants");
+var _eth = require("@subwallet/extension-base/utils/eth");
+var _parseTransaction2 = require("@subwallet/extension-base/utils/eth/parseTransaction");
+var _keyring = require("@subwallet/keyring");
+var _uiKeyring = require("@subwallet/ui-keyring");
+var _accounts = require("@subwallet/ui-keyring/observable/accounts");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _ethereumjsTx = require("ethereumjs-tx");
+var _types = require("@polkadot/types");
+var _util = require("@polkadot/util");
+var _utilCrypto = require("@polkadot/util-crypto");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const ETH_DERIVE_DEFAULT = '/m/44\'/60\'/0\'/0/0';
+function getSuri(seed, type) {
+  return type === 'ethereum' ? `${seed}${ETH_DERIVE_DEFAULT}` : seed;
+}
+function transformAccounts(accounts) {
+  return Object.values(accounts).map(_ref => {
+    let {
+      json: {
+        address,
+        meta
+      },
+      type
+    } = _ref;
+    return {
+      address,
+      ...meta,
+      type
+    };
+  });
+}
+const ACCOUNT_ALL_JSON = {
+  address: _constants.ALL_ACCOUNT_KEY,
+  name: 'All'
+};
+class KoniExtension {
+  #koniState;
+  constructor(state) {
+    this.#koniState = state;
+  }
+
+  /// Clone from PolkadotJs
+  accountsCreateExternal(_ref2) {
+    let {
+      address,
+      genesisHash,
+      name
+    } = _ref2;
+    _uiKeyring.keyring.addExternal(address, {
+      genesisHash,
+      name
+    });
+    return true;
+  }
+  accountsCreateHardware(_ref3) {
+    let {
+      accountIndex,
+      address,
+      addressOffset,
+      genesisHash,
+      hardwareType,
+      name
+    } = _ref3;
+    _uiKeyring.keyring.addHardware(address, hardwareType, {
+      accountIndex,
+      addressOffset,
+      genesisHash,
+      name
+    });
+    return true;
+  }
+  accountsCreateSuri(_ref4) {
+    let {
+      genesisHash,
+      name,
+      suri,
+      type
+    } = _ref4;
+    _uiKeyring.keyring.addUri(getSuri(suri, type), {
+      genesisHash,
+      name
+    }, type);
+    return true;
+  }
+  accountsChangePassword(_ref5) {
+    let {
+      address,
+      newPass,
+      oldPass
+    } = _ref5;
+    const pair = _uiKeyring.keyring.getPair(address);
+    (0, _util.assert)(pair, 'Unable to find pair');
+    try {
+      if (!pair.isLocked) {
+        pair.lock();
+      }
+      pair.decodePkcs8(oldPass);
+    } catch (error) {
+      throw new Error('oldPass is invalid');
+    }
+    _uiKeyring.keyring.encryptAccount(pair, newPass);
+    return true;
+  }
+  accountsEdit(_ref6) {
+    let {
+      address,
+      name
+    } = _ref6;
+    const pair = _uiKeyring.keyring.getPair(address);
+    (0, _util.assert)(pair, 'Unable to find pair');
+    _uiKeyring.keyring.saveAccountMeta(pair, {
+      ...pair.meta,
+      name
+    });
+    return true;
+  }
+  accountsExport(_ref7) {
+    let {
+      address,
+      password
+    } = _ref7;
+    return {
+      exportedJson: _uiKeyring.keyring.backupAccount(_uiKeyring.keyring.getPair(address), password)
+    };
+  }
+  accountsShow(_ref8) {
+    let {
+      address,
+      isShowing
+    } = _ref8;
+    const pair = _uiKeyring.keyring.getPair(address);
+    (0, _util.assert)(pair, 'Unable to find pair');
+    _uiKeyring.keyring.saveAccountMeta(pair, {
+      ...pair.meta,
+      isHidden: !isShowing
+    });
+    return true;
+  }
+  accountsValidate(_ref9) {
+    let {
+      address,
+      password
+    } = _ref9;
+    try {
+      _uiKeyring.keyring.backupAccount(_uiKeyring.keyring.getPair(address), password);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  // FIXME This looks very much like what we have in Tabs
+  accountsSubscribe(id, port) {
+    const cb = (0, _subscriptions.createSubscription)(id, port);
+    const subscription = _accounts.accounts.subject.subscribe(accounts => cb(transformAccounts(accounts)));
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+      subscription.unsubscribe();
+    });
+    return true;
+  }
+  metadataApprove(_ref10) {
+    let {
+      id
+    } = _ref10;
+    const queued = this.#koniState.getMetaRequest(id);
+    (0, _util.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(_ref11) {
+    let {
+      id
+    } = _ref11;
+    const queued = this.#koniState.getMetaRequest(id);
+    (0, _util.assert)(queued, 'Unable to find request');
+    const {
+      reject
+    } = queued;
+    reject(new Error('Rejected'));
+    return true;
+  }
+  metadataSubscribe(id, port) {
+    const cb = (0, _subscriptions.createSubscription)(id, port);
+    const subscription = this.#koniState.metaSubject.subscribe(requests => cb(requests));
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+      subscription.unsubscribe();
+    });
+    return true;
+  }
+  jsonRestore(_ref12) {
+    let {
+      file,
+      password
+    } = _ref12;
+    try {
+      _uiKeyring.keyring.restoreAccount(file, password, true);
+    } catch (error) {
+      throw new Error(error.message);
+    }
+  }
+  batchRestore(_ref13) {
+    let {
+      file,
+      password
+    } = _ref13;
+    try {
+      _uiKeyring.keyring.restoreAccounts(file, password);
+    } catch (error) {
+      throw new Error(error.message);
+    }
+  }
+  jsonGetAccountInfo(json) {
+    try {
+      const {
+        address,
+        meta: {
+          genesisHash,
+          name
+        },
+        type
+      } = _uiKeyring.keyring.createFromJson(json);
+      return {
+        address,
+        genesisHash,
+        name,
+        type
+      };
+    } catch (e) {
+      console.error(e);
+      throw new Error(e.message);
+    }
+  }
+  seedCreate(_ref14) {
+    let {
+      length = _Extension.SEED_DEFAULT_LENGTH,
+      seed: _seed,
+      type
+    } = _ref14;
+    const seed = _seed || (0, _utilCrypto.mnemonicGenerate)(length);
+    return {
+      address: _uiKeyring.keyring.createFromUri(getSuri(seed, type), {}, type).address,
+      seed
+    };
+  }
+  seedValidate(_ref15) {
+    let {
+      suri,
+      type
+    } = _ref15;
+    const {
+      phrase
+    } = (0, _utilCrypto.keyExtractSuri)(suri);
+    if ((0, _util.isHex)(phrase)) {
+      (0, _util.assert)((0, _util.isHex)(phrase, 256), 'Hex seed needs to be 256-bits');
+    } else {
+      // sadly isHex detects as string, so we need a cast here
+      (0, _util.assert)(_Extension.SEED_LENGTHS.includes(phrase.split(' ').length), `Mnemonic needs to contain ${_Extension.SEED_LENGTHS.join(', ')} words`);
+      (0, _util.assert)((0, _utilCrypto.mnemonicValidate)(phrase), 'Not a valid mnemonic seed');
+    }
+    return {
+      address: _uiKeyring.keyring.createFromUri(getSuri(suri, type), {}, type).address,
+      suri
+    };
+  }
+
+  // TODO: move to request service
+  signingApproveSignature(_ref16) {
+    let {
+      id,
+      signature
+    } = _ref16;
+    const queued = this.#koniState.getSignRequest(id);
+    (0, _util.assert)(queued, 'Unable to find request');
+    const {
+      resolve
+    } = queued;
+    resolve({
+      id,
+      signature
+    });
+    return true;
+  }
+
+  // TODO: move to request service
+  signingCancel(_ref17) {
+    let {
+      id
+    } = _ref17;
+    const queued = this.#koniState.getSignRequest(id);
+    (0, _util.assert)(queued, 'Unable to find request');
+    const {
+      reject
+    } = queued;
+    reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.USER_REJECT_REQUEST));
+    return true;
+  }
+
+  // FIXME This looks very much like what we have in authorization
+  signingSubscribe(id, port) {
+    const cb = (0, _subscriptions.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 (!_defaults.ALLOWED_PATH.includes(path)) {
+      console.error('Not allowed to open the url:', url);
+      return false;
+    }
+    (0, _helpers.withErrorLog)(() => chrome.tabs.create({
+      url
+    }));
+    return true;
+  }
+  derive(parentAddress, suri, password, metadata) {
+    const parentPair = _uiKeyring.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(_ref18) {
+    let {
+      parentAddress,
+      parentPassword,
+      suri
+    } = _ref18;
+    const childPair = this.derive(parentAddress, suri, parentPassword, {});
+    return {
+      address: childPair.address,
+      suri
+    };
+  }
+  derivationCreate(_ref19) {
+    let {
+      genesisHash,
+      name,
+      parentAddress,
+      parentPassword,
+      suri
+    } = _ref19;
+    const childPair = this.derive(parentAddress, suri, parentPassword, {
+      genesisHash,
+      name,
+      parentAddress,
+      suri
+    });
+    _uiKeyring.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 _uiKeyring.keyring.decodeAddress(key, ignoreChecksum, ss58Format);
+  };
+  encodeAddress = (key, ss58Format) => {
+    return _uiKeyring.keyring.encodeAddress(key, ss58Format);
+  };
+  accountExportPrivateKey(_ref20) {
+    let {
+      address,
+      password
+    } = _ref20;
+    return this.#koniState.accountExportPrivateKey({
+      address,
+      password
+    });
+  }
+  checkPublicAndSecretKey(request) {
+    return this.#koniState.checkPublicAndSecretKey(request);
+  }
+  async accountsGetAllWithCurrentAddress(id, port) {
+    const cb = (0, _subscriptions.createSubscription)(id, port);
+    return await new Promise(resolve => {
+      const subscription = _accounts.accounts.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 === _constants.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) || _constants.ALL_GENESIS_HASH;
+              }
+            }
+            resolve(accountsWithCurrentAddress);
+            cb(accountsWithCurrentAddress);
+          });
+        }, 300);
+      });
+      this.createUnsubscriptionHandle(id, subscription.unsubscribe);
+      port.onDisconnect.addListener(() => {
+        this.cancelSubscription(id);
+      });
+    });
+  }
+  accountsGetAll(id, port) {
+    const cb = (0, _subscriptions.createSubscription)(id, port);
+    const subscription = _uiKeyring.keyring.keyringOption.optionsSubject.subscribe(options => {
+      const optionsInputAddress = {
+        options
+      };
+      cb(optionsInputAddress);
+    });
+    this.createUnsubscriptionHandle(id, subscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return id;
+  }
+  saveRecentAccountId(_ref21) {
+    let {
+      accountId
+    } = _ref21;
+    return _uiKeyring.keyring.saveRecent(accountId);
+  }
+  triggerAccountsSubscription() {
+    const accountsSubject = _accounts.accounts.subject;
+    accountsSubject.next(accountsSubject.getValue());
+    return true;
+  }
+  _getAuthListV2() {
+    return new Promise((resolve, reject) => {
+      this.#koniState.getAuthorize(rs => {
+        const accounts = _accounts.accounts.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 = (0, _subscriptions.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(_ref22) {
+    let {
+      accounts,
+      id
+    } = _ref22;
+    const queued = this.#koniState.getAuthRequestV2(id);
+    (0, _util.assert)(queued, 'Unable to find request');
+    const {
+      resolve
+    } = queued;
+    resolve({
+      accounts,
+      result: true
+    });
+    return true;
+  }
+  authorizeRejectV2(_ref23) {
+    let {
+      id
+    } = _ref23;
+    const queued = this.#koniState.getAuthRequestV2(id);
+    (0, _util.assert)(queued, 'Unable to find request');
+    const {
+      reject
+    } = queued;
+    reject(new Error('Rejected'));
+    return true;
+  }
+  authorizeCancelV2(_ref24) {
+    let {
+      id
+    } = _ref24;
+    const queued = this.#koniState.getAuthRequestV2(id);
+    (0, _util.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 => {
+      (0, _util.assert)(value, 'The source is not known');
+      delete value[url];
+      this.#koniState.setAuthorize(value, () => {
+        callBack && callBack(value);
+      });
+    });
+  }
+  forgetSite(data, id, port) {
+    const cb = (0, _subscriptions.createSubscription)(id, port);
+    this._forgetSite(data.url, items => {
+      cb(items);
+    });
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return true;
+  }
+  _forgetAllSite(callBack) {
+    this.#koniState.getAuthorize(value => {
+      (0, _util.assert)(value, 'The source is not known');
+      value = {};
+      this.#koniState.setAuthorize(value, () => {
+        callBack && callBack(value);
+      });
+    });
+  }
+  forgetAllSite(id, port) {
+    const cb = (0, _subscriptions.createSubscription)(id, port);
+    this._forgetAllSite(items => {
+      cb(items);
+    });
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return true;
+  }
+  getNonReadonlyAccounts() {
+    const storedAccounts = _accounts.accounts.subject.getValue();
+    const transformedAccounts = transformAccounts(storedAccounts);
+    return transformedAccounts.filter(a => !a.isReadOnly).map(a => a.address);
+  }
+  isAddressValidWithAuthType(address, accountAuthType) {
+    if (accountAuthType === 'substrate') {
+      return !(0, _utilCrypto.isEthereumAddress)(address);
+    } else if (accountAuthType === 'evm') {
+      return (0, _utilCrypto.isEthereumAddress)(address);
+    }
+    return true;
+  }
+  filterAccountsByAccountAuthType(accounts, accountAuthType) {
+    if (accountAuthType === 'substrate') {
+      return accounts.filter(address => !(0, _utilCrypto.isEthereumAddress)(address));
+    } else if (accountAuthType === 'evm') {
+      return accounts.filter(address => (0, _utilCrypto.isEthereumAddress)(address));
+    } else {
+      return accounts;
+    }
+  }
+  _changeAuthorizationAll(connectValue, callBack) {
+    this.#koniState.getAuthorize(value => {
+      (0, _util.assert)(value, 'The source is not known');
+      const nonReadonlyAccounts = this.getNonReadonlyAccounts();
+      Object.keys(value).forEach(url => {
+        if (!value[url].isAllowed) {
+          return;
+        }
+        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 = (0, _subscriptions.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 => {
+      (0, _util.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 => {
+        (0, _util.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 = (0, _subscriptions.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 => {
+      (0, _util.assert)(value, 'The source is not known');
+      if (this.isAddressValidWithAuthType(address, value[url].accountAuthType)) {
+        value[url].isAllowedMap[address] = connectValue;
+        console.log('Devbu: ', value);
+        this.#koniState.setAuthorize(value, () => {
+          callBack && callBack(value);
+        });
+      } else {
+        callBack && callBack(value);
+      }
+    });
+  }
+  _changeAuthorizationBlock(connectValue, id) {
+    this.#koniState.getAuthorize(value => {
+      (0, _util.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 => {
+      (0, _util.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 = (0, _subscriptions.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 = (0, _subscriptions.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 = (0, _subscriptions.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 = (0, _subscriptions.createSubscription)(id, port);
+    this.#koniState.setTheme(data, cb);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return true;
+  }
+  setCamera(_ref25) {
+    let {
+      camera
+    } = _ref25;
+    this.#koniState.setCamera(camera);
+    return true;
+  }
+  saveBrowserConfirmationType(data, id, port) {
+    const cb = (0, _subscriptions.createSubscription)(id, port);
+    this.#koniState.setBrowserConfirmationType(data, cb);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return true;
+  }
+  async subscribeSettings(id, port) {
+    const cb = (0, _subscriptions.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 = (0, _subscriptions.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: _constants.ALL_GENESIS_HASH,
+          allGenesisHash: _constants.ALL_GENESIS_HASH || undefined
+        };
+      } else {
+        accountInfo.address = address;
+        if (address !== _constants.ALL_ACCOUNT_KEY) {
+          const currentKeyPair = _uiKeyring.keyring.getAccount(address);
+          accountInfo.currentGenesisHash = (currentKeyPair === null || currentKeyPair === void 0 ? void 0 : currentKeyPair.meta.genesisHash) || _constants.ALL_GENESIS_HASH;
+        } else {
+          accountInfo.currentGenesisHash = accountInfo.allGenesisHash || _constants.ALL_GENESIS_HASH;
+        }
+      }
+      this.#koniState.setCurrentAccount(accountInfo, () => {
+        callback && callback(accountInfo);
+      });
+    });
+  }
+  updateCurrentAccountAddress(address) {
+    this._saveCurrentAccountAddress(address, () => {
+      this.triggerAccountsSubscription();
+    });
+    return true;
+  }
+  saveCurrentAccountAddress(data, id, port) {
+    const cb = (0, _subscriptions.createSubscription)(id, port);
+    this._saveCurrentAccountAddress(data.address, cb);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return true;
+  }
+  async getAssetSetting() {
+    return this.#koniState.chainService.getAssetSettings();
+  }
+  subscribeAssetSetting(id, port) {
+    const cb = (0, _subscriptions.createSubscription)(id, port);
+    const assetSettingSubscription = this.#koniState.chainService.subscribeAssetSettings().subscribe(cb);
+    this.createUnsubscriptionHandle(id, assetSettingSubscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return this.getAssetSetting();
+  }
+  async updateAssetSetting(params) {
+    try {
+      await this.#koniState.chainService.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 = (0, _subscriptions.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 = (0, _subscriptions.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 = (0, _subscriptions.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 = (0, _keyring.createPair)({
+      toSS58: this.encodeAddress,
+      type: cryptoType
+    }, {
+      publicKey: this.decodeAddress(json.address, true)
+    }, json.meta, (0, _util.isHex)(json.encoded) ? (0, _util.hexToU8a)(json.encoded) : (0, _utilCrypto.base64Decode)(json.encoded), encType);
+
+    // unlock then lock (locking cleans secretKey, so needs to be last)
+    try {
+      pair.decodePkcs8(password);
+      pair.lock();
+      return true;
+    } catch (e) {
+      console.error(e);
+      return false;
+    }
+  }
+  validatedAccountsPassword(json, password) {
+    try {
+      (0, _util.u8aToString)((0, _utilCrypto.jsonDecrypt)(json, password));
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  _addAddressToAuthList(address, isAllowed) {
+    this.#koniState.getAuthorize(value => {
+      if (value && Object.keys(value).length) {
+        Object.keys(value).forEach(url => {
+          if (this.isAddressValidWithAuthType(address, value[url].accountAuthType)) {
+            value[url].isAllowedMap[address] = isAllowed;
+          }
+        });
+        this.#koniState.setAuthorize(value);
+      }
+    });
+  }
+  _addAddressesToAuthList(addresses, isAllowed) {
+    this.#koniState.getAuthorize(value => {
+      if (value && Object.keys(value).length) {
+        Object.keys(value).forEach(url => {
+          addresses.forEach(address => {
+            if (this.isAddressValidWithAuthType(address, value[url].accountAuthType)) {
+              value[url].isAllowedMap[address] = isAllowed;
+            }
+          });
+        }); /**/
+
+        this.#koniState.setAuthorize(value);
+      }
+    });
+  }
+  async accountsCreateSuriV2(_ref26) {
+    let {
+      genesisHash,
+      isAllowed,
+      name,
+      password,
+      suri: _suri,
+      types
+    } = _ref26;
+    const addressDict = {};
+    let changedAccount = false;
+    const hasMasterPassword = _uiKeyring.keyring.keyring.hasMasterPassword;
+    if (!hasMasterPassword) {
+      if (!password) {
+        throw Error('Require password to set up master password');
+      } else {
+        _uiKeyring.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 = _uiKeyring.keyring.createFromUri(suri, {}, type).address;
+      addressDict[type] = address;
+      const newAccountName = type === 'ethereum' ? `${name} - EVM` : name;
+      _uiKeyring.keyring.addUri(suri, {
+        genesisHash,
+        name: newAccountName
+      }, type);
+      this._addAddressToAuthList(address, isAllowed);
+      if (!changedAccount) {
+        if (types.length === 1) {
+          this.#koniState.setCurrentAccount({
+            address,
+            currentGenesisHash: genesisHash || null,
+            allGenesisHash
+          });
+        } else {
+          this.#koniState.setCurrentAccount({
+            address: _constants.ALL_ACCOUNT_KEY,
+            currentGenesisHash: allGenesisHash || null,
+            allGenesisHash
+          });
+        }
+        changedAccount = true;
+      }
+    });
+    await new Promise(resolve => {
+      this.#koniState.addAccountRef(Object.values(addressDict), () => {
+        resolve();
+      });
+    });
+    return addressDict;
+  }
+  async accountsForgetOverride(_ref27) {
+    let {
+      address
+    } = _ref27;
+    _uiKeyring.keyring.forgetAccount(address);
+    await new Promise(resolve => {
+      this.#koniState.removeAccountRef(address, () => {
+        resolve();
+      });
+    });
+
+    // Remove from auth list
+    await new Promise(resolve => {
+      this.#koniState.getAuthorize(value => {
+        if (value && Object.keys(value).length) {
+          Object.keys(value).forEach(url => {
+            delete value[url].isAllowedMap[address];
+          });
+          this.#koniState.setAuthorize(value, resolve);
+        } else {
+          resolve();
+        }
+      });
+    });
+
+    // Remove history
+    await this.#koniState.historyService.removeHistoryByAddress(address);
+
+    // Set current account to all account
+    await new Promise(resolve => {
+      this.#koniState.getCurrentAccount(_ref28 => {
+        let {
+          allGenesisHash
+        } = _ref28;
+        this.#koniState.setCurrentAccount({
+          currentGenesisHash: allGenesisHash || null,
+          address: _constants.ALL_ACCOUNT_KEY
+        }, resolve);
+      });
+    });
+    return true;
+  }
+  seedCreateV2(_ref29) {
+    let {
+      length = _Extension.SEED_DEFAULT_LENGTH,
+      seed: _seed,
+      types
+    } = _ref29;
+    const seed = _seed || (0, _utilCrypto.mnemonicGenerate)(length);
+    const rs = {
+      seed: seed,
+      addressMap: {}
+    };
+    types === null || types === void 0 ? void 0 : types.forEach(type => {
+      rs.addressMap[type] = _uiKeyring.keyring.createFromUri(getSuri(seed, type), {}, type).address;
+    });
+    return rs;
+  }
+  seedValidateV2(_ref30) {
+    let {
+      suri,
+      types
+    } = _ref30;
+    const {
+      phrase
+    } = (0, _utilCrypto.keyExtractSuri)(suri);
+    if ((0, _util.isHex)(phrase)) {
+      (0, _util.assert)((0, _util.isHex)(phrase, 256), 'Hex seed needs to be 256-bits');
+    } else {
+      // sadly isHex detects as string, so we need a cast here
+      (0, _util.assert)(_Extension.SEED_LENGTHS.includes(phrase.split(' ').length), `Mnemonic needs to contain ${_Extension.SEED_LENGTHS.join(', ')} words`);
+      (0, _util.assert)((0, _utilCrypto.mnemonicValidate)(phrase), 'Not a valid mnemonic seed');
+    }
+    const rs = {
+      seed: suri,
+      addressMap: {}
+    };
+    types && types.forEach(type => {
+      rs.addressMap[type] = _uiKeyring.keyring.createFromUri(getSuri(suri, type), {}, type).address;
+    });
+    return rs;
+  }
+  _checkValidatePrivateKey(_ref31) {
+    let {
+      suri,
+      types
+    } = _ref31;
+    let autoAddPrefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    const {
+      phrase
+    } = (0, _utilCrypto.keyExtractSuri)(suri);
+    const rs = {
+      autoAddPrefix: autoAddPrefix,
+      addressMap: {}
+    };
+    types && types.forEach(type => {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      rs.addressMap[type] = '';
+    });
+    if ((0, _util.isHex)(phrase) && (0, _util.isHex)(phrase, 256)) {
+      types && types.forEach(type => {
+        rs.addressMap[type] = _uiKeyring.keyring.createFromUri(getSuri(suri, type), {}, type).address;
+      });
+    } else {
+      rs.autoAddPrefix = false;
+      (0, _util.assert)(false, 'Not valid private key');
+    }
+    return rs;
+  }
+  metamaskPrivateKeyValidateV2(_ref32) {
+    let {
+      suri,
+      types
+    } = _ref32;
+    const isValidSuri = suri.startsWith('0x');
+    if (isValidSuri) {
+      return this._checkValidatePrivateKey({
+        suri,
+        types
+      });
+    } else {
+      return this._checkValidatePrivateKey({
+        suri: `0x${suri}`,
+        types
+      }, true);
+    }
+  }
+  deriveV2(parentAddress, suri, metadata) {
+    const parentPair = _uiKeyring.keyring.getPair(parentAddress);
+    if (parentPair.isLocked) {
+      _uiKeyring.keyring.unlockPair(parentPair.address);
+    }
+    try {
+      return parentPair.derive(suri, metadata);
+    } catch (err) {
+      throw new Error(`"${suri}" is not a valid derivation path`);
+    }
+  }
+  derivationCreateV2(_ref33) {
+    let {
+      genesisHash,
+      isAllowed,
+      name,
+      parentAddress,
+      suri
+    } = _ref33;
+    const childPair = this.deriveV2(parentAddress, suri, {
+      genesisHash,
+      name,
+      parentAddress,
+      suri
+    });
+    const address = childPair.address;
+    this._saveCurrentAccountAddress(address, () => {
+      _uiKeyring.keyring.addPair(childPair, true);
+      this._addAddressToAuthList(address, isAllowed);
+    });
+    return true;
+  }
+  jsonRestoreV2(_ref34) {
+    let {
+      address,
+      file,
+      isAllowed,
+      password,
+      withMasterPassword
+    } = _ref34;
+    const isPasswordValidated = this.validatePassword(file, password);
+    if (isPasswordValidated) {
+      try {
+        this._saveCurrentAccountAddress(address, () => {
+          _uiKeyring.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(_ref35) {
+    let {
+      accountsInfo,
+      file,
+      isAllowed,
+      password
+    } = _ref35;
+    const addressList = accountsInfo.map(acc => acc.address);
+    const isPasswordValidated = this.validatedAccountsPassword(file, password);
+    if (isPasswordValidated) {
+      try {
+        this._saveCurrentAccountAddress(addressList[0], () => {
+          _uiKeyring.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');
+    }
+  }
+  getNftCollection() {
+    return this.#koniState.getNftCollection();
+  }
+  subscribeNftCollection(id, port) {
+    const cb = (0, _subscriptions.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 = (0, _subscriptions.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 = (0, _subscriptions.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 = (0, _subscriptions.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 = (0, _subscriptions.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();
+  }
+  validateTransfer(tokenSlug, from, to, value, transferAll) {
+    const errors = [];
+    const keypair = _uiKeyring.keyring.getPair(from);
+    let transferValue;
+    if (!transferAll) {
+      if (value === undefined) {
+        errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS, 'Require transfer value'));
+      }
+      if (value) {
+        transferValue = new _util.BN(value);
+      }
+    }
+    const tokenInfo = this.#koniState.getAssetBySlug(tokenSlug);
+    if (!tokenInfo) {
+      errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS, 'Not found token from registry'));
+    }
+    if ((0, _utilCrypto.isEthereumAddress)(from) && (0, _utilCrypto.isEthereumAddress)(to) && !(0, _utils._isNativeToken)(tokenInfo) && !(0, _utils._isTokenEvmSmartContract)(tokenInfo)) {
+      errors.push(new _TransactionError.TransactionError(_KoniTypes.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 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 = _KoniTypes.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 this.#koniState.balanceService.getTokenFreeBalance(from, networkKey, tokenSlug);
+    let edAsWarning = false;
+    if ((0, _utilCrypto.isEthereumAddress)(from) && (0, _utilCrypto.isEthereumAddress)(to)) {
+      chainType = _KoniTypes.ChainType.EVM;
+      const txVal = transferAll ? freeBalance.value : value || '0';
+
+      // Estimate with EVM API
+      if ((0, _utils._isTokenEvmSmartContract)(tokenInfo)) {
+        [transaction, transferAmount.value] = await (0, _transfer3.getERC20TransactionObject)((0, _utils._getContractAddressOfToken)(tokenInfo), chainInfo, from, to, txVal, !!transferAll, evmApiMap);
+      } else {
+        [transaction, transferAmount.value] = await (0, _transfer3.getEVMTransactionObject)(chainInfo, to, txVal, !!transferAll, evmApiMap);
+        edAsWarning = true;
+      }
+    } else {
+      const substrateApi = this.#koniState.getSubstrateApi(networkKey);
+      [transaction, transferAmount.value] = await (0, _transfer.createTransferExtrinsic)({
+        transferAll: !!transferAll,
+        value: value || '0',
+        from: from,
+        networkKey,
+        tokenInfo,
+        to: to,
+        substrateApi
+      });
+      edAsWarning = true;
+    }
+    const transferNativeAmount = isTransferNativeToken ? transferAmount.value : '0';
+    return this.#koniState.transactionService.handleTransaction({
+      errors,
+      warnings,
+      address: from,
+      chain: networkKey,
+      chainType,
+      transferNativeAmount,
+      transaction,
+      data: inputData,
+      extrinsicType: isTransferNativeToken ? _KoniTypes.ExtrinsicType.TRANSFER_BALANCE : _KoniTypes.ExtrinsicType.TRANSFER_TOKEN,
+      ignoreWarnings: transferAll,
+      isTransferAll: transferAll,
+      edAsWarning: edAsWarning
+    });
+  }
+  validateCrossChainTransfer(destinationNetworkKey, sendingTokenSlug, sender, sendingValue) {
+    const errors = [];
+    const keypair = _uiKeyring.keyring.getPair(sender);
+    const transferValue = new _util.BN(sendingValue);
+    const originTokenInfo = this.#koniState.getAssetBySlug(sendingTokenSlug);
+    const destinationTokenInfo = this.#koniState.getXcmEqualAssetByChain(destinationNetworkKey, sendingTokenSlug);
+    if (!destinationTokenInfo) {
+      errors.push(new _TransactionError.TransactionError(_KoniTypes.TransferTxErrorType.INVALID_TOKEN, 'Not found token from registry'));
+    }
+    return [errors, keypair, transferValue, originTokenInfo, destinationTokenInfo];
+  }
+  async makeCrossChainTransfer(inputData) {
+    const {
+      destinationNetworkKey,
+      from,
+      originNetworkKey,
+      to,
+      tokenSlug,
+      value
+    } = inputData;
+    const [errors, fromKeyPair,, originTokenInfo, destinationTokenInfo] = this.validateCrossChainTransfer(destinationNetworkKey, tokenSlug, from, value);
+    let extrinsic = null;
+    if (errors.length > 0) {
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors(errors);
+    }
+    if (fromKeyPair && destinationTokenInfo) {
+      const substrateApi = this.#koniState.getSubstrateApi(originNetworkKey);
+      const chainInfoMap = this.#koniState.getChainInfoMap();
+      extrinsic = await (0, _xcm.createXcmExtrinsic)({
+        destinationTokenInfo,
+        originTokenInfo,
+        sendingValue: value,
+        recipient: to,
+        chainInfoMap,
+        substrateApi
+      });
+    }
+    return await this.#koniState.transactionService.handleTransaction({
+      url: _constants2.EXTENSION_REQUEST_URL,
+      address: from,
+      chain: originNetworkKey,
+      transaction: extrinsic,
+      data: inputData,
+      extrinsicType: _KoniTypes.ExtrinsicType.TRANSFER_XCM,
+      chainType: _KoniTypes.ChainType.SUBSTRATE,
+      transferNativeAmount: (0, _utils._isNativeToken)(originTokenInfo) ? value : '0',
+      errors
+    });
+  }
+  async evmNftSubmitTransaction(inputData) {
+    const {
+      networkKey,
+      params,
+      recipientAddress,
+      senderAddress
+    } = inputData;
+    const contractAddress = params.contractAddress;
+    const tokenId = params.tokenId;
+    const transaction = await (0, _transfer3.getERC721Transaction)(this.#koniState.getEvmApi(networkKey), contractAddress, senderAddress, recipientAddress, tokenId);
+    return await this.#koniState.transactionService.handleTransaction({
+      address: senderAddress,
+      chain: networkKey,
+      chainType: _KoniTypes.ChainType.EVM,
+      data: inputData,
+      extrinsicType: _KoniTypes.ExtrinsicType.SEND_NFT,
+      transaction,
+      url: _constants2.EXTENSION_REQUEST_URL
+    });
+  }
+  async upsertChain(data) {
+    try {
+      return await 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);
+  }
+  async enableChain(networkKey) {
+    return await this.#koniState.enableChain(networkKey);
+  }
+  async validateNetwork(_ref36) {
+    let {
+      existedChainSlug,
+      provider
+    } = _ref36;
+    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;
+    }
+  }
+  async upsertCustomToken(data) {
+    try {
+      await 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 && (0, _utils._isCustomAsset)(assetSlug)) {
+      if ((0, _utils._isAssetSmartContractNft)(assetInfo)) {
+        // check if deleting a smart contract NFT
+        await this.#koniState.deleteNftCollection(assetInfo.originChain, (0, _utils._getContractAddressOfToken)(assetInfo));
+      }
+      this.#koniState.deleteCustomAssets([assetSlug]);
+      return true;
+    }
+    return false;
+  }
+  async validateCustomAsset(data) {
+    return await this.#koniState.validateCustomAsset(data);
+  }
+  async getAddressFreeBalance(_ref37) {
+    let {
+      address,
+      networkKey,
+      token
+    } = _ref37;
+    return await this.#koniState.balanceService.getTokenFreeBalance(address, networkKey, token);
+  }
+  async subscribeAddressFreeBalance(_ref38, id, port) {
+    let {
+      address,
+      networkKey,
+      token
+    } = _ref38;
+    const cb = (0, _subscriptions.createSubscription)(id, port);
+    const [unsub, currentFreeBalance] = await this.#koniState.balanceService.subscribeTokenFreeBalance(address, networkKey, token, cb);
+    this.createUnsubscriptionHandle(id, unsub);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return currentFreeBalance;
+  }
+  async transferCheckReferenceCount(_ref39) {
+    let {
+      address,
+      networkKey
+    } = _ref39;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-return
+    return await (0, _transfer.checkReferenceCount)(networkKey, address, this.#koniState.getSubstrateApiMap(), this.#koniState.getChainInfo(networkKey));
+  }
+  async transferCheckSupporting(_ref40) {
+    let {
+      networkKey,
+      tokenSlug
+    } = _ref40;
+    const tokenInfo = this.#koniState.getAssetBySlug(tokenSlug);
+    return await (0, _transfer.checkSupportTransfer)(networkKey, tokenInfo, this.#koniState.getSubstrateApiMap(), this.#koniState.getChainInfo(networkKey));
+  }
+  transferGetExistentialDeposit(_ref41) {
+    let {
+      tokenSlug
+    } = _ref41;
+    const tokenInfo = this.#koniState.getAssetBySlug(tokenSlug);
+    return (0, _utils._getTokenMinAmount)(tokenInfo);
+  }
+  async substrateNftSubmitTransaction(inputData) {
+    const {
+      params,
+      recipientAddress,
+      senderAddress
+    } = inputData;
+    const isSendingSelf = (0, _transfer2.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 ? (0, _transfer2.getNftTransferExtrinsic)(networkKey, apiProps, senderAddress, recipientAddress, params || {}) : await (0, _wasm.getPSP34TransferExtrinsic)(networkKey, apiProps, senderAddress, recipientAddress, params || {});
+    const rs = await this.#koniState.transactionService.handleTransaction({
+      address: senderAddress,
+      chain: networkKey,
+      transaction: extrinsic,
+      data: {
+        ...inputData,
+        isSendingSelf
+      },
+      extrinsicType: _KoniTypes.ExtrinsicType.SEND_NFT,
+      chainType: _KoniTypes.ChainType.SUBSTRATE
+    });
+    return {
+      ...rs,
+      isSendingSelf
+    };
+  }
+  async enableChains(targetKeys) {
+    try {
+      await Promise.all(targetKeys.map(networkKey => this.enableChain(networkKey)));
+    } catch (e) {
+      return false;
+    }
+    return true;
+  }
+  getAccountMeta(_ref42) {
+    let {
+      address
+    } = _ref42;
+    const pair = _uiKeyring.keyring.getPair(address);
+    (0, _util.assert)(pair, 'Unable to find pair');
+    return {
+      meta: pair.meta
+    };
+  }
+
+  // private async isInWalletAccount (address?: string) {
+  //   return new Promise((resolve) => {
+  //     if (address) {
+  //       accountsObservable.subject.subscribe((storedAccounts: SubjectInfo): void => {
+  //         if (storedAccounts[address]) {
+  //           resolve(true);
+  //         }
+  //
+  //         resolve(false);
+  //       });
+  //     } else {
+  //       resolve(false);
+  //     }
+  //   });
+  // }
+
+  accountsTie2(_ref43) {
+    let {
+      address,
+      genesisHash
+    } = _ref43;
+    return this.#koniState.setAccountTie(address, genesisHash);
+  }
+  async accountsCreateExternalV2(_ref44) {
+    let {
+      address,
+      genesisHash,
+      isAllowed,
+      isEthereum,
+      isReadOnly,
+      name
+    } = _ref44;
+    try {
+      let result;
+      try {
+        const exists = _uiKeyring.keyring.getPair(address);
+        if (exists) {
+          if (exists.type === (isEthereum ? 'ethereum' : 'sr25519')) {
+            return [{
+              code: _KoniTypes.AccountExternalErrorCode.INVALID_ADDRESS,
+              message: 'Account exists'
+            }];
+          }
+        }
+      } catch (e) {}
+      if (isEthereum) {
+        const chainInfoMap = this.#koniState.getChainInfoMap();
+        let _gen = '';
+        if (genesisHash) {
+          for (const network of Object.values(chainInfoMap)) {
+            if ((0, _utils._getEvmChainId)(network) === parseInt(genesisHash)) {
+              // TODO: pure EVM chains do not have genesisHash
+              _gen = (0, _utils._getSubstrateGenesisHash)(network);
+            }
+          }
+        }
+        result = _uiKeyring.keyring.keyring.addFromAddress(address, {
+          name,
+          isExternal: true,
+          isReadOnly,
+          genesisHash: _gen
+        }, null, 'ethereum');
+        _uiKeyring.keyring.saveAccount(result);
+      } else {
+        result = _uiKeyring.keyring.addExternal(address, {
+          genesisHash,
+          name,
+          isReadOnly
+        }).pair;
+      }
+      const _address = result.address;
+      await new Promise(resolve => {
+        this.#koniState.addAccountRef([_address], () => {
+          resolve();
+        });
+      });
+      await new Promise(resolve => {
+        this._saveCurrentAccountAddress(_address, () => {
+          this._addAddressToAuthList(_address, isAllowed);
+          resolve();
+        });
+      });
+      return [];
+    } catch (e) {
+      return [{
+        code: _KoniTypes.AccountExternalErrorCode.KEYRING_ERROR,
+        message: e.message
+      }];
+    }
+  }
+  async accountsCreateHardwareV2(_ref45) {
+    let {
+      accountIndex,
+      address,
+      addressOffset,
+      genesisHash,
+      hardwareType,
+      isAllowed,
+      name
+    } = _ref45;
+    const key = _uiKeyring.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(_ref46) {
+    let {
+      accounts
+    } = _ref46;
+    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 = _uiKeyring.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: _constants.ALL_ACCOUNT_KEY,
+        currentGenesisHash: allGenesisHash || null,
+        allGenesisHash
+      });
+    }
+    await new Promise(resolve => {
+      this.#koniState.addAccountRef(addresses, () => {
+        resolve();
+      });
+    });
+    return true;
+  }
+  async accountsCreateWithSecret(_ref47) {
+    let {
+      isAllow,
+      isEthereum,
+      name,
+      publicKey,
+      secretKey
+    } = _ref47;
+    try {
+      let keyringPair = null;
+      if (isEthereum) {
+        const _secret = (0, _util.hexStripPrefix)(secretKey);
+        if (_secret.length === 64) {
+          const suri = `0x${_secret}`;
+          const {
+            phrase
+          } = (0, _utilCrypto.keyExtractSuri)(suri);
+          if ((0, _util.isHex)(phrase) && (0, _util.isHex)(phrase, 256)) {
+            const type = 'ethereum';
+            keyringPair = _uiKeyring.keyring.addUri(getSuri(suri, type), {
+              name: name
+            }, type).pair;
+          }
+        }
+      } else {
+        keyringPair = _uiKeyring.keyring.keyring.addFromPair({
+          publicKey: (0, _util.hexToU8a)(publicKey),
+          secretKey: (0, _util.hexToU8a)(secretKey)
+        }, {
+          name
+        });
+        _uiKeyring.keyring.addPair(keyringPair, true);
+      }
+      if (!keyringPair) {
+        return {
+          success: false,
+          errors: [{
+            code: _KoniTypes.AccountExternalErrorCode.KEYRING_ERROR,
+            message: '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: _KoniTypes.AccountExternalErrorCode.KEYRING_ERROR,
+          message: e.message
+        }]
+      };
+    }
+  }
+
+  /// External account
+
+  rejectExternalRequest(request) {
+    const {
+      id,
+      message,
+      throwError
+    } = request;
+    const promise = this.#koniState.getExternalRequest(id);
+    if (promise.status === _KoniTypes.ExternalRequestPromiseStatus.PENDING && promise.reject) {
+      if (throwError) {
+        promise.reject(new Error(message));
+      } else {
+        promise.reject();
+      }
+      this.#koniState.updateExternalRequest(id, {
+        status: _KoniTypes.ExternalRequestPromiseStatus.REJECTED,
+        message: message,
+        reject: undefined,
+        resolve: undefined
+      });
+    }
+  }
+  resolveQrTransfer(request) {
+    const {
+      data,
+      id
+    } = request;
+    const promise = this.#koniState.getExternalRequest(id);
+    if (promise.status === _KoniTypes.ExternalRequestPromiseStatus.PENDING) {
+      promise.resolve && promise.resolve(data);
+      this.#koniState.updateExternalRequest(id, {
+        status: _KoniTypes.ExternalRequestPromiseStatus.COMPLETED,
+        reject: undefined,
+        resolve: undefined
+      });
+    }
+  }
+  subscribeConfirmations(id, port) {
+    const cb = (0, _subscriptions.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 ((0, _utils._isChainEvmCompatible)(networkInfo)) {
+          return networkInfo;
+        }
+      }
+      return null;
+    }
+    for (const n in chainInfoMap) {
+      if (!Object.prototype.hasOwnProperty.call(chainInfoMap, n)) {
+        continue;
+      }
+      const networkInfo = chainInfoMap[n];
+      if ((0, _utils._getEvmChainId)(networkInfo) === chainId) {
+        return networkInfo;
+      }
+    }
+    return null;
+  }
+
+  // Parse transaction
+
+  parseSubstrateTransaction(_ref48) {
+    let {
+      data,
+      networkKey
+    } = _ref48;
+    const apiProps = this.#koniState.getSubstrateApi(networkKey);
+    const apiPromise = apiProps.api;
+    return (0, _parseTransaction.parseSubstrateTransaction)(data, apiPromise);
+  }
+  async parseEVMRLP(_ref49) {
+    let {
+      data
+    } = _ref49;
+    return await (0, _parseTransaction2.parseEvmRlp)(data, this.#koniState.getChainInfoMap(), this.#koniState.getEvmApiMap());
+  }
+
+  // Sign
+
+  qrSignSubstrate(_ref50) {
+    let {
+      address,
+      data,
+      networkKey
+    } = _ref50;
+    const pair = _uiKeyring.keyring.getPair(address);
+    (0, _util.assert)(pair, 'Unable to find pair');
+    if (pair.isLocked) {
+      _uiKeyring.keyring.unlockPair(pair.address);
+    }
+    let signed = (0, _util.hexStripPrefix)((0, _util.u8aToHex)(pair.sign(data, {
+      withType: true
+    })));
+    const network = this.#koniState.getChainInfo(networkKey);
+    if ((0, _utils._isChainEvmCompatible)(network)) {
+      signed = signed.substring(2);
+    }
+    return {
+      signature: signed
+    };
+  }
+  async qrSignEVM(_ref51) {
+    let {
+      address,
+      chainId,
+      message,
+      type
+    } = _ref51;
+    let signed;
+    const network = this.getNetworkJsonByChainId(chainId);
+    if (!network) {
+      throw new Error('Cannot find network');
+    }
+    const pair = _uiKeyring.keyring.getPair(address);
+    if (!pair) {
+      throw Error('Unable to find pair');
+    }
+    if (pair.isLocked) {
+      _uiKeyring.keyring.unlockPair(pair.address);
+    }
+    if (type === 'message') {
+      let data = message;
+      if ((0, _util.isHex)(message)) {
+        data = message;
+      } else if ((0, _util.isAscii)(message)) {
+        data = `0x${message}`;
+      }
+      signed = await pair.evmSigner.signMessage(data, 'personal_sign');
+    } else {
+      const tx = (0, _eth.createTransactionFromRLP)(message);
+      if (!tx) {
+        throw new Error(`Cannot create tx from ${message}`);
+      }
+      const txObject = {
+        gasPrice: new _bignumber.default(tx.gasPrice).toNumber(),
+        to: tx.action,
+        value: new _bignumber.default(tx.value).toNumber(),
+        data: tx.data,
+        nonce: new _bignumber.default(tx.nonce).toNumber(),
+        gas: new _bignumber.default(tx.gas).toNumber()
+      };
+      const common = _common.default.forCustomChain('mainnet', {
+        name: network.name,
+        networkId: (0, _utils._getEvmChainId)(network),
+        chainId: (0, _utils._getEvmChainId)(network)
+      }, 'petersburg');
+
+      // @ts-ignore
+      const transaction = new _ethereumjsTx.Transaction(txObject, {
+        common
+      });
+      pair.evmSigner.signTransaction(transaction);
+      signed = (0, _eth.signatureToHex)({
+        r: (0, _util.u8aToHex)(transaction.r),
+        s: (0, _util.u8aToHex)(transaction.s),
+        v: (0, _util.u8aToHex)(transaction.v)
+      });
+    }
+    return {
+      signature: (0, _util.hexStripPrefix)(signed)
+    };
+  }
+  async subscribeChainStakingMetadata(id, port) {
+    const cb = (0, _subscriptions.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 = (0, _subscriptions.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(_ref52) {
+    let {
+      chain,
+      type
+    } = _ref52;
+    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
+    } = (0, _utils._getChainNativeTokenBasicInfo)(chainInfo);
+    return await (0, _bonding.getValidatorsInfo)(chain, apiProps, decimals, chainStakingMetadata);
+  }
+  async getNominationPoolOptions(chain) {
+    const substrateApi = this.#koniState.getSubstrateApi(chain);
+    return await (0, _bonding.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.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS)]);
+    }
+    const chainInfo = this.#koniState.getChainInfo(chain);
+    const substrateApi = this.#koniState.getSubstrateApi(chain);
+    const extrinsic = await (0, _bonding.getBondingExtrinsic)(chainInfo, amount, nominatorMetadata, selectedValidators, substrateApi);
+    return await this.#koniState.transactionService.handleTransaction({
+      address: nominatorMetadata.address,
+      chain: chain,
+      chainType: _KoniTypes.ChainType.SUBSTRATE,
+      data: inputData,
+      extrinsicType: _KoniTypes.ExtrinsicType.STAKING_BOND,
+      transaction: extrinsic,
+      url: _constants2.EXTENSION_REQUEST_URL
+    });
+  }
+  async submitUnbonding(inputData) {
+    const {
+      amount,
+      chain,
+      nominatorMetadata,
+      validatorAddress
+    } = inputData;
+    if (!amount || !nominatorMetadata) {
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS)]);
+    }
+    const substrateApi = this.#koniState.getSubstrateApi(chain);
+    const extrinsic = await (0, _bonding.getUnbondingExtrinsic)(nominatorMetadata, amount, chain, substrateApi, validatorAddress);
+    return await this.#koniState.transactionService.handleTransaction({
+      address: nominatorMetadata.address,
+      chain: chain,
+      transaction: extrinsic,
+      data: inputData,
+      extrinsicType: _KoniTypes.ExtrinsicType.STAKING_UNBOND,
+      chainType: _KoniTypes.ChainType.SUBSTRATE
+    });
+  }
+  async submitStakeWithdrawal(inputData) {
+    const {
+      chain,
+      nominatorMetadata,
+      validatorAddress
+    } = inputData;
+    if (!nominatorMetadata) {
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS)]);
+    }
+    const dotSamaApi = this.#koniState.getSubstrateApi(chain);
+    const extrinsic = await (0, _bonding.getWithdrawalExtrinsic)(dotSamaApi, chain, nominatorMetadata, validatorAddress);
+    return await this.#koniState.transactionService.handleTransaction({
+      address: nominatorMetadata.address,
+      chain: chain,
+      transaction: extrinsic,
+      data: inputData,
+      extrinsicType: _KoniTypes.ExtrinsicType.STAKING_WITHDRAW,
+      chainType: _KoniTypes.ChainType.SUBSTRATE
+    });
+  }
+  async submitStakeClaimReward(inputData) {
+    const {
+      address,
+      bondReward,
+      chain,
+      stakingType
+    } = inputData;
+    if (!address) {
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS)]);
+    }
+    const substrateApi = this.#koniState.getSubstrateApi(chain);
+    const extrinsic = await (0, _bonding.getClaimRewardExtrinsic)(substrateApi, chain, address, stakingType, bondReward);
+    return await this.#koniState.transactionService.handleTransaction({
+      address,
+      chain: chain,
+      transaction: extrinsic,
+      data: inputData,
+      extrinsicType: _KoniTypes.ExtrinsicType.STAKING_CLAIM_REWARD,
+      chainType: _KoniTypes.ChainType.SUBSTRATE
+    });
+  }
+  async submitCancelStakeWithdrawal(inputData) {
+    const {
+      address,
+      chain,
+      selectedUnstaking
+    } = inputData;
+    if (!chain || !selectedUnstaking) {
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS)]);
+    }
+    const substrateApi = this.#koniState.getSubstrateApi(chain);
+    const extrinsic = await (0, _bonding.getCancelWithdrawalExtrinsic)(substrateApi, chain, selectedUnstaking);
+    return await this.#koniState.transactionService.handleTransaction({
+      address,
+      chain,
+      transaction: extrinsic,
+      data: inputData,
+      extrinsicType: _KoniTypes.ExtrinsicType.STAKING_CANCEL_UNSTAKE,
+      chainType: _KoniTypes.ChainType.SUBSTRATE
+    });
+  }
+  async submitPoolingBonding(inputData) {
+    const {
+      address,
+      amount,
+      chain,
+      nominatorMetadata,
+      selectedPool
+    } = inputData;
+    const substrateApi = this.#koniState.getSubstrateApi(chain);
+    const extrinsic = await (0, _relayChain.getPoolingBondingExtrinsic)(substrateApi, amount, selectedPool.id, nominatorMetadata);
+    return await this.#koniState.transactionService.handleTransaction({
+      address,
+      chain,
+      transaction: extrinsic,
+      data: inputData,
+      extrinsicType: _KoniTypes.ExtrinsicType.STAKING_JOIN_POOL,
+      chainType: _KoniTypes.ChainType.SUBSTRATE
+    });
+  }
+  async submitPoolingUnbonding(inputData) {
+    const {
+      amount,
+      chain,
+      nominatorMetadata
+    } = inputData;
+    const substrateApi = this.#koniState.getSubstrateApi(chain);
+    const extrinsic = await (0, _relayChain.getPoolingUnbondingExtrinsic)(substrateApi, amount, nominatorMetadata);
+    return await this.#koniState.transactionService.handleTransaction({
+      address: nominatorMetadata.address,
+      chain,
+      transaction: extrinsic,
+      data: inputData,
+      extrinsicType: _KoniTypes.ExtrinsicType.STAKING_LEAVE_POOL,
+      chainType: _KoniTypes.ChainType.SUBSTRATE
+    });
+  }
+
+  // EVM Transaction
+  async parseContractInput(_ref53) {
+    let {
+      chainId,
+      contract,
+      data
+    } = _ref53;
+    const network = this.getNetworkJsonByChainId(chainId);
+    return await (0, _parseTransaction2.parseContractInput)(data, contract, network);
+  }
+  async submitTuringStakeCompounding(inputData) {
+    const {
+      accountMinimum,
+      address,
+      bondedAmount,
+      collatorAddress,
+      networkKey
+    } = inputData;
+    if (!address) {
+      return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS)]);
+    }
+    const dotSamaApi = this.#koniState.getSubstrateApi(networkKey);
+    const chainInfo = this.#koniState.getChainInfo(networkKey);
+    const {
+      decimals
+    } = (0, _utils._getChainNativeTokenBasicInfo)(chainInfo);
+    const parsedAccountMinimum = parseFloat(accountMinimum) * 10 ** decimals;
+    const extrinsic = await (0, _paraChain.getTuringCompoundExtrinsic)(dotSamaApi, address, collatorAddress, parsedAccountMinimum.toString(), bondedAmount);
+    return await this.#koniState.transactionService.handleTransaction({
+      address,
+      chain: networkKey,
+      transaction: extrinsic,
+      data: inputData,
+      extrinsicType: _KoniTypes.ExtrinsicType.STAKING_COMPOUNDING,
+      chainType: _KoniTypes.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 (0, _paraChain.getTuringCancelCompoundingExtrinsic)(dotSamaApi, taskId);
+    return await this.#koniState.transactionService.handleTransaction({
+      address,
+      chain: networkKey,
+      transaction: extrinsic,
+      data: inputData,
+      extrinsicType: _KoniTypes.ExtrinsicType.STAKING_CANCEL_COMPOUNDING,
+      chainType: _KoniTypes.ChainType.SUBSTRATE
+    });
+  }
+  keyringStateSubscribe(id, port) {
+    const cb = (0, _subscriptions.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(_ref54) {
+    let {
+      createNew,
+      newPassword,
+      oldPassword
+    } = _ref54;
+    try {
+      // Remove isMasterPassword meta if createNew
+      if (createNew) {
+        const pairs = _uiKeyring.keyring.getPairs();
+        for (const pair of pairs) {
+          const meta = {
+            ...pair.meta,
+            isMasterPassword: false
+          };
+          if (!meta.originGenesisHash) {
+            meta.genesisHash = '';
+          }
+          pair.setMeta(meta);
+          _uiKeyring.keyring.saveAccountMeta(pair, pair.meta);
+        }
+      }
+      _uiKeyring.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(_ref55) {
+    let {
+      address,
+      password
+    } = _ref55;
+    try {
+      _uiKeyring.keyring.migrateWithMasterPassword(address, password);
+    } catch (e) {
+      console.error(e);
+      return {
+        errors: [e.message],
+        status: false
+      };
+    }
+    return {
+      status: true,
+      errors: []
+    };
+  }
+  keyringUnlock(_ref56) {
+    let {
+      password
+    } = _ref56;
+    try {
+      _uiKeyring.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() {
+    _uiKeyring.keyring.lockAll();
+    this.#koniState.setKeyringState({
+      isReady: true,
+      hasMasterPassword: true,
+      isLocked: true
+    });
+  }
+  keyringExportMnemonic(_ref57) {
+    let {
+      address,
+      password
+    } = _ref57;
+    const pair = _uiKeyring.keyring.getPair(address);
+    const result = pair.exportMnemonic(password);
+    return {
+      result
+    };
+  }
+
+  /// Signing external request
+  signingApprovePasswordV2(_ref58) {
+    let {
+      id
+    } = _ref58;
+    const queued = this.#koniState.getSignRequest(id);
+    (0, _util.assert)(queued, 'Unable to find request');
+    const {
+      reject,
+      request,
+      resolve
+    } = queued;
+    const pair = _uiKeyring.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) {
+      _uiKeyring.keyring.unlockPair(address);
+    }
+    const {
+      payload
+    } = request;
+    const registry = new _types.TypeRegistry();
+    if ((0, _Extension.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(_ref59) {
+    let {
+      isAllowed,
+      items,
+      parentAddress
+    } = _ref59;
+    const parentPair = _uiKeyring.keyring.getPair(parentAddress);
+    const isEvm = parentPair.type === 'ethereum';
+    if (parentPair.isLocked) {
+      _uiKeyring.keyring.unlockPair(parentPair.address);
+    }
+    const createChild = _ref60 => {
+      let {
+        name,
+        suri
+      } = _ref60;
+      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;
+        _uiKeyring.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: _constants.ALL_ACCOUNT_KEY,
+        currentGenesisHash: null
+      });
+    }
+    return true;
+  }
+  derivationCreateV3(_ref61) {
+    let {
+      address: parentAddress
+    } = _ref61;
+    const parentPair = _uiKeyring.keyring.getPair(parentAddress);
+    const isEvm = parentPair.type === 'ethereum';
+    if (parentPair.isLocked) {
+      _uiKeyring.keyring.unlockPair(parentPair.address);
+    }
+    const pairs = _uiKeyring.keyring.getPairs();
+    const children = pairs.filter(p => p.meta.parentAddress === parentAddress);
+    const name = `Account ${pairs.length}`;
+    let index = isEvm ? 1 : 0;
+    let valid = false;
+    do {
+      const exist = children.find(p => p.meta.suri === `//${index}`);
+      if (exist) {
+        index++;
+      } else {
+        valid = true;
+      }
+    } while (!valid);
+    const meta = {
+      name,
+      parentAddress,
+      suri: `//${index}`
+    };
+    const childPair = isEvm ? parentPair.deriveEvm(index, meta) : parentPair.derive(meta.suri, meta);
+    const address = childPair.address;
+    this._saveCurrentAccountAddress(address, () => {
+      _uiKeyring.keyring.addPair(childPair, true);
+      this._addAddressToAuthList(address, true);
+    });
+    return true;
+  }
+  validateDerivePath(_ref62) {
+    let {
+      parentAddress,
+      suri
+    } = _ref62;
+    const parentPair = _uiKeyring.keyring.getPair(parentAddress);
+    const isEvm = parentPair.type === 'ethereum';
+    if (parentPair.isLocked) {
+      _uiKeyring.keyring.unlockPair(parentPair.address);
+    }
+    const meta = {
+      parentAddress
+    };
+    let childPair;
+    if (isEvm) {
+      let index = 0;
+      try {
+        const reg = /^\d+$/;
+        const path = suri.split('//')[1];
+        if (reg.test(path)) {
+          index = parseInt(path);
+        }
+      } catch (e) {}
+      if (!index) {
+        throw Error('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(_ref63) {
+    let {
+      limit,
+      page,
+      parentAddress
+    } = _ref63;
+    const parentPair = _uiKeyring.keyring.getPair(parentAddress);
+    const isEvm = parentPair.type === 'ethereum';
+    if (parentPair.isLocked) {
+      _uiKeyring.keyring.unlockPair(parentPair.address);
+    }
+    const start = (page - 1) * limit + (isEvm ? 1 : 0);
+    const end = start + limit;
+    const result = [];
+    for (let i = start; i < end; i++) {
+      const suri = `//${i}`;
+      const pair = isEvm ? parentPair.deriveEvm(i, {}) : parentPair.derive(suri, {});
+      result.push({
+        address: pair.address,
+        suri: suri
+      });
+    }
+    return {
+      result: result
+    };
+  }
+
+  // ChainService -------------------------------------------------
+  subscribeChainInfoMap(id, port) {
+    const cb = (0, _subscriptions.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 = (0, _subscriptions.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 = (0, _subscriptions.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 = (0, _subscriptions.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();
+  }
+  subscribeXcmRefMap(id, port) {
+    const cb = (0, _subscriptions.createSubscription)(id, port);
+    const xcmRefSubscription = this.#koniState.subscribeXcmRefMap().subscribe({
+      next: rs => {
+        cb(rs);
+      }
+    });
+    this.createUnsubscriptionHandle(id, xcmRefSubscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return this.#koniState.getXcmRefMap();
+  }
+  getSupportedSmartContractTypes() {
+    return this.#koniState.getSupportedSmartContractTypes();
+  }
+  getTransaction(_ref64) {
+    let {
+      id
+    } = _ref64;
+    const {
+      transaction,
+      ...transactionResult
+    } = this.#koniState.transactionService.getTransaction(id);
+    return transactionResult;
+  }
+  subscribeTransactions(id, port) {
+    const cb = (0, _subscriptions.createSubscription)(id, port);
+    function convertRs(rs) {
+      return Object.fromEntries(Object.entries(rs).map(_ref65 => {
+        let [key, value] = _ref65;
+        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());
+  }
+  subscribeNotifications(id, port) {
+    const cb = (0, _subscriptions.createSubscription)(id, port);
+    const notificationSubject = this.#koniState.notificationService.getNotificationSubject();
+    const notificationSubscription = notificationSubject.subscribe(rs => {
+      cb(rs);
+    });
+    port.onDisconnect.addListener(() => {
+      notificationSubscription.unsubscribe();
+      this.cancelSubscription(id);
+    });
+    return notificationSubject.value;
+  }
+
+  // --------------------------------------------------------------
+  // 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(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.saveCamera)':
+        return this.setCamera(request);
+      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.subscribeXcmRefMap)':
+        return this.subscribeXcmRefMap(id, port);
+      case 'pri(chainService.getSupportedContractTypes)':
+        return this.getSupportedSmartContractTypes();
+      case 'pri(chainService.enableChain)':
+        return await this.enableChain(request);
+      case 'pri(chainService.disableChain)':
+        return await 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 await this.upsertChain(request);
+      case 'pri(chainService.resetDefaultChains)':
+        return this.resetDefaultNetwork();
+      case 'pri(chainService.enableChains)':
+        return await 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 await 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 await 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.get)':
+        return this.getAddressFreeBalance(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);
+
+      // 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);
+
+      // 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);
+
+      /// 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);
+
+      // Notification
+      case 'pri(notifications.subscribe)':
+        return this.subscribeNotifications(id, port);
+
+      // Default
+      default:
+        throw new Error(`Unable to handle message of type ${type}`);
+    }
+  }
+}
+exports.default = KoniExtension;