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

package/koni/background/handlers/State.js

@@ -0,0 +1,1454 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { ChainInfoMap } from '@subwallet/chain-list';
+import { EvmProviderError } from '@subwallet/extension-base/background/errors/EvmProviderError';
+import { withErrorLog } from '@subwallet/extension-base/background/handlers/helpers';
+import { isSubscriptionRunning, unsubscribe } from '@subwallet/extension-base/background/handlers/subscriptions';
+import { APIItemState, BasicTxErrorType, ChainType, EvmProviderErrorType, ExternalRequestPromiseStatus, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { ALL_ACCOUNT_KEY, ALL_GENESIS_HASH } from '@subwallet/extension-base/constants';
+import { getFreeBalance } from '@subwallet/extension-base/koni/api/dotsama/balance';
+import { BalanceService } from '@subwallet/extension-base/services/balance-service';
+import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import { _PREDEFINED_SINGLE_MODES } from '@subwallet/extension-base/services/chain-service/constants';
+import { _getEvmChainId, _getSubstrateGenesisHash, _isAssetFungibleToken, _isChainEnabled, _isChainTestNet, _isSubstrateParachain, _parseMetadataForSmartContractAsset } from '@subwallet/extension-base/services/chain-service/utils';
+import { HistoryService } from '@subwallet/extension-base/services/history-service';
+import { PriceService } from '@subwallet/extension-base/services/price-service';
+import RequestService from '@subwallet/extension-base/services/request-service';
+import SettingService from '@subwallet/extension-base/services/setting-service/SettingService';
+import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
+import TransactionService from '@subwallet/extension-base/services/transaction-service';
+import { CurrentAccountStore } from '@subwallet/extension-base/stores';
+import AccountRefStore from '@subwallet/extension-base/stores/AccountRef';
+import AssetSettingStore from '@subwallet/extension-base/stores/AssetSetting';
+import { isContractAddress, parseContractInput } from '@subwallet/extension-base/utils/eth/parseTransaction';
+import { decodePair } from '@subwallet/keyring/pair/decode';
+import { keyring } from '@subwallet/ui-keyring';
+import { accounts } from '@subwallet/ui-keyring/observable/accounts';
+import SimpleKeyring from 'eth-simple-keyring';
+import { Subject } from 'rxjs';
+import { assert, BN, hexStripPrefix, hexToU8a, isHex, logger as createLogger, u8aToHex } from '@polkadot/util';
+import { base64Decode, isEthereumAddress, keyExtractSuri } from '@polkadot/util-crypto';
+import { KoniCron } from "../cron.js";
+import { KoniSubscription } from "../subscription.js";
+const ETH_DERIVE_DEFAULT = '/m/44\'/60\'/0\'/0/0';
+
+// List of providers passed into constructor. This is the list of providers
+// exposed by the extension.
+
+const getSuri = (seed, type) => {
+  return type === 'ethereum' ? `${seed}${ETH_DERIVE_DEFAULT}` : seed;
+};
+const generateDefaultCrowdloanMap = () => {
+  const crowdloanMap = {};
+  Object.entries(ChainInfoMap).forEach(([networkKey, chainInfo]) => {
+    if (_isSubstrateParachain(chainInfo)) {
+      crowdloanMap[networkKey] = {
+        state: APIItemState.PENDING,
+        contribute: '0'
+      };
+    }
+  });
+  return crowdloanMap;
+};
+export default class KoniState {
+  injectedProviders = new Map();
+  unsubscriptionMap = {};
+  assetSettingStore = new AssetSettingStore();
+  currentAccountStore = new CurrentAccountStore();
+  accountRefStore = new AccountRefStore();
+  keyringStateSubject = new Subject();
+  externalRequest = {};
+  keyringState = {
+    isReady: false,
+    isLocked: true,
+    hasMasterPassword: false
+  };
+  serviceInfoSubject = new Subject();
+  balanceMap = {};
+  balanceSubject = new Subject();
+  crowdloanMap = generateDefaultCrowdloanMap();
+  crowdloanSubject = new Subject();
+  nftTransferSubject = new Subject();
+  // Only for rendering nft after transfer
+  nftTransferState = {
+    cronUpdate: false,
+    forceUpdate: false
+  };
+  nftSubject = new Subject();
+  stakingSubject = new Subject();
+  chainStakingMetadataSubject = new Subject();
+  stakingNominatorMetadataSubject = new Subject();
+  stakingRewardSubject = new Subject();
+  stakingRewardState = {
+    ready: false,
+    slowInterval: [],
+    fastInterval: []
+  };
+  lazyMap = {};
+
+  // TODO: consider making chainService public (or getter) and call function directly
+
+  ready = false;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor(providers = {}) {
+    this.providers = providers;
+    this.dbService = new DatabaseService();
+    this.chainService = new ChainService(this.dbService);
+    this.settingService = new SettingService();
+    this.requestService = new RequestService(this.chainService);
+    this.priceService = new PriceService(this.dbService, this.chainService);
+    this.balanceService = new BalanceService(getFreeBalance);
+    this.historyService = new HistoryService(this.dbService, this.chainService);
+    this.transactionService = new TransactionService(this.chainService, this.requestService, this.balanceService, this.historyService);
+    this.subscription = new KoniSubscription(this, this.dbService);
+    this.cron = new KoniCron(this, this.subscription, this.dbService);
+    this.logger = createLogger('State');
+    this.init();
+  }
+
+  // Clone from polkadot.js
+  get knownMetadata() {
+    return this.requestService.knownMetadata;
+  }
+  injectMetadata(url, request) {
+    return this.requestService.injectMetadata(url, request);
+  }
+  getMetaRequest(id) {
+    return this.requestService.getMetaRequest(id);
+  }
+  getSignRequest(id) {
+    return this.requestService.getSignRequest(id);
+  }
+
+  // List all providers the extension is exposing
+  rpcListProviders() {
+    return Promise.resolve(Object.keys(this.providers).reduce((acc, key) => {
+      acc[key] = this.providers[key].meta;
+      return acc;
+    }, {}));
+  }
+  rpcSend(request, port) {
+    const provider = this.injectedProviders.get(port);
+    assert(provider, 'Cannot call pub(rpc.subscribe) before provider is set');
+    return provider.send(request.method, request.params);
+  }
+
+  // Start a provider, return its meta
+  rpcStartProvider(key, port) {
+    assert(Object.keys(this.providers).includes(key), `Provider ${key} is not exposed by extension`);
+    if (this.injectedProviders.get(port)) {
+      return Promise.resolve(this.providers[key].meta);
+    }
+
+    // Instantiate the provider
+    this.injectedProviders.set(port, this.providers[key].start());
+
+    // Close provider connection when page is closed
+    port.onDisconnect.addListener(() => {
+      const provider = this.injectedProviders.get(port);
+      if (provider) {
+        withErrorLog(() => provider.disconnect());
+      }
+      this.injectedProviders.delete(port);
+    });
+    return Promise.resolve(this.providers[key].meta);
+  }
+  rpcSubscribe({
+    method,
+    params,
+    type
+  }, cb, port) {
+    const provider = this.injectedProviders.get(port);
+    assert(provider, 'Cannot call pub(rpc.subscribe) before provider is set');
+    return provider.subscribe(type, method, params, cb);
+  }
+  rpcSubscribeConnected(_request, cb, port) {
+    const provider = this.injectedProviders.get(port);
+    assert(provider, 'Cannot call pub(rpc.subscribeConnected) before provider is set');
+    cb(null, provider.isConnected); // Immediately send back current isConnected
+    provider.on('connected', () => cb(null, true));
+    provider.on('disconnected', () => cb(null, false));
+  }
+  rpcUnsubscribe(request, port) {
+    const provider = this.injectedProviders.get(port);
+    assert(provider, 'Cannot call pub(rpc.unsubscribe) before provider is set');
+    return provider.unsubscribe(request.type, request.method, request.subscriptionId);
+  }
+  saveMetadata(meta) {
+    this.requestService.saveMetadata(meta);
+  }
+  setNotification(notification) {
+    this.requestService.setNotification(notification);
+    return true;
+  }
+  sign(url, request, account) {
+    return this.requestService.sign(url, request, account);
+  }
+  get authSubjectV2() {
+    return this.requestService.authSubjectV2;
+  }
+  generateDefaultBalanceMap() {
+    const balanceMap = {};
+    const activeChains = this.chainService.getActiveChainInfoMap();
+    Object.values(activeChains).forEach(chainInfo => {
+      const chainAssetMap = this.chainService.getFungibleTokensByChain(chainInfo.slug);
+      Object.keys(chainAssetMap).forEach(assetSlug => {
+        balanceMap[assetSlug] = {
+          tokenSlug: assetSlug,
+          free: '',
+          locked: '',
+          state: APIItemState.PENDING
+        };
+      });
+    });
+    return balanceMap;
+  }
+  initAssetSetting() {
+    this.assetSettingStore.get('AssetSetting', storedAssetSettings => {
+      const activeChainSlugs = this.chainService.getActiveChainSlugs();
+      const assetRegistry = this.chainService.getAssetRegistry();
+      const assetSettings = storedAssetSettings || {};
+      if (Object.keys(assetSettings).length === 0) {
+        // only initiate the first time
+        Object.values(assetRegistry).forEach(assetInfo => {
+          const isSettingExisted = (assetInfo.slug in assetSettings);
+
+          // Set visible for every enabled chains
+          if (activeChainSlugs.includes(assetInfo.originChain) && !isSettingExisted) {
+            // Setting only exist when set either by chain settings or user
+            assetSettings[assetInfo.slug] = {
+              visible: true
+            };
+          }
+        });
+        this.setAssetSettings(assetSettings);
+      }
+      this.logger.log('Done init asset settings');
+    });
+  }
+  init() {
+    this.chainService.init(() => {
+      this.onReady(); // TODO: do better than a callback
+      this.initAssetSetting();
+      this.updateServiceInfo();
+      this.startSubscription();
+      this.logger.log('Done init state');
+    });
+  }
+  startSubscription() {
+    this.dbService.subscribeChainStakingMetadata([], data => {
+      this.chainStakingMetadataSubject.next(data);
+    });
+    this.dbService.subscribeNominatorMetadata(data => {
+      this.stakingNominatorMetadataSubject.next(data);
+    });
+  }
+  onReady() {
+    this.subscription.start();
+    this.cron.start();
+    this.ready = true;
+    this.logger.log('State is ready');
+  }
+  isReady() {
+    return this.ready;
+  }
+  getKeyringState() {
+    return this.keyringState;
+  }
+  subscribeKeyringState() {
+    return this.keyringStateSubject;
+  }
+  setKeyringState(data, callback) {
+    this.keyringStateSubject.next(data);
+    this.keyringState = data;
+    callback && callback();
+  }
+  lazyNext = (key, callback) => {
+    if (this.lazyMap[key]) {
+      // @ts-ignore
+      clearTimeout(this.lazyMap[key]);
+    }
+    const lazy = setTimeout(() => {
+      callback();
+      clearTimeout(lazy);
+    }, 300);
+    this.lazyMap[key] = lazy;
+  };
+  getAuthRequestV2(id) {
+    return this.requestService.getAuthRequestV2(id);
+  }
+  setAuthorize(data, callback) {
+    this.requestService.setAuthorize(data, callback);
+  }
+  getAuthorize(update) {
+    this.requestService.getAuthorize(update);
+  }
+  subscribeEvmChainChange() {
+    return this.requestService.subscribeEvmChainChange;
+  }
+  subscribeAuthorizeUrlSubject() {
+    return this.requestService.subscribeAuthorizeUrlSubject;
+  }
+  getAuthList() {
+    return this.requestService.getAuthList();
+  }
+  getAddressList(value = false) {
+    const addressList = Object.keys(accounts.subject.value);
+    return addressList.reduce((addressList, v) => ({
+      ...addressList,
+      [v]: value
+    }), {});
+  }
+  async authorizeUrlV2(url, request) {
+    return this.requestService.authorizeUrlV2(url, request);
+  }
+  getNativeTokenInfo(networkKey) {
+    return this.chainService.getNativeTokenInfo(networkKey);
+  }
+  getChainInfo(networkKey) {
+    return this.chainService.getChainInfoByKey(networkKey);
+  }
+  async getChainStakingMetadata() {
+    return this.dbService.getChainStakingMetadata();
+  }
+  async getStakingMetadataByChain(chain, type) {
+    return this.dbService.getStakingMetadataByChain(chain, type);
+  }
+  async getNominatorMetadata() {
+    return this.dbService.getNominatorMetadata();
+  }
+  async getStaking() {
+    const addresses = await this.getDecodedAddresses();
+    const stakings = await this.dbService.getStakings(addresses, this.activeChainSlugs);
+    return {
+      ready: true,
+      details: stakings
+    };
+  }
+  async getStakingOwnersByChains(chains) {
+    const stakings = await this.dbService.getStakingsByChains(chains);
+    const addresses = [];
+    stakings.forEach(staking => {
+      if (!addresses.includes(staking.address)) {
+        addresses.push(staking.address);
+      }
+    });
+    return addresses;
+  }
+  async getPooledStakingRecordsByAddress(addresses) {
+    return await this.dbService.getPooledStakings(addresses, this.activeChainSlugs);
+  }
+
+  // TODO: delete later
+  // public async getStoredStaking (address: string) {
+  //   const items = await this.dbService.stores.staking.getDataByAddressAsObject(address);
+  //
+  //   return items || {};
+  // }
+
+  subscribeStaking() {
+    return this.stakingSubject;
+  }
+  subscribeChainStakingMetadata() {
+    return this.chainStakingMetadataSubject;
+  }
+  subscribeNominatorMetadata() {
+    return this.stakingNominatorMetadataSubject;
+  }
+  ensureUrlAuthorizedV2(url) {
+    return this.requestService.ensureUrlAuthorizedV2(url);
+  }
+  setStakingItem(networkKey, item) {
+    this.dbService.updateStaking(networkKey, item.address, item).catch(e => this.logger.warn(e));
+  }
+  updateChainStakingMetadata(item) {
+    this.dbService.updateChainStakingMetadata(item).catch(e => this.logger.warn(e));
+  }
+  updateStakingNominatorMetadata(item) {
+    this.dbService.updateNominatorMetadata(item).catch(e => this.logger.warn(e));
+  }
+  setNftTransfer(data, callback) {
+    this.nftTransferState = data;
+    if (callback) {
+      callback(data);
+    }
+    this.nftTransferSubject.next(data);
+  }
+  getNftTransfer() {
+    return this.nftTransferState;
+  }
+  getNftTransferSubscription(update) {
+    update(this.nftTransferState);
+  }
+  subscribeNftTransfer() {
+    return this.nftTransferSubject;
+  }
+  setNftCollection(network, data, callback) {
+    this.dbService.addNftCollection(data).catch(e => this.logger.warn(e));
+    callback && callback(data);
+  }
+  getNftCollection() {
+    return this.dbService.getAllNftCollection(this.activeChainSlugs);
+  }
+  subscribeNftCollection() {
+    return this.dbService.stores.nftCollection.subscribeNftCollection(this.activeChainSlugs);
+  }
+  async resetNft(newAddress) {
+    this.getNft().then(data => this.nftSubject.next(data || {
+      nftList: [],
+      total: 0
+    })).catch(e => this.logger.warn(e));
+    const addresses = await this.getDecodedAddresses(newAddress);
+    this.dbService.subscribeNft(addresses, this.activeChainSlugs, nfts => {
+      this.nftSubject.next({
+        nftList: nfts,
+        total: nfts.length
+      });
+    });
+  }
+  updateNftData(network, nftData, address, callback) {
+    this.dbService.addNft(address, nftData).catch(e => this.logger.warn(e));
+    callback && callback(nftData);
+  }
+  updateNftIds(chain, address, collectionId, nftIds) {
+    this.dbService.deleteRemovedNftsFromCollection(chain, address, collectionId, nftIds).catch(e => this.logger.warn(e));
+  }
+  removeNfts(chain, address, collectionId, nftIds) {
+    return this.dbService.removeNfts(chain, address, collectionId, nftIds);
+  }
+  deleteNftCollection(chain, collectionId) {
+    return this.dbService.deleteNftCollection(chain, collectionId);
+  }
+  updateCollectionIds(chain, address, collectionIds = []) {
+    this.dbService.deleteNftsFromRemovedCollection(chain, address, collectionIds);
+  }
+  async getNft() {
+    const addresses = await this.getDecodedAddresses();
+    if (!addresses.length) {
+      return;
+    }
+    const nfts = await this.dbService.getNft(addresses, this.activeChainSlugs);
+    return {
+      nftList: nfts,
+      total: nfts.length
+    };
+  }
+  subscribeNft() {
+    return this.nftSubject;
+  }
+  resetStakingReward() {
+    this.stakingRewardState.slowInterval = [];
+    this.stakingRewardSubject.next(this.stakingRewardState);
+  }
+  updateStakingReward(stakingRewardData, type, callback) {
+    this.stakingRewardState.ready = true;
+    this.stakingRewardState[type] = stakingRewardData;
+    if (callback) {
+      callback(this.stakingRewardState);
+    }
+    this.stakingRewardSubject.next(this.stakingRewardState);
+  }
+  updateStakingRewardReady(ready) {
+    this.stakingRewardState.ready = ready;
+    this.stakingRewardSubject.next(this.stakingRewardState);
+  }
+  getAccountRefMap(callback) {
+    const refMap = {};
+    this.accountRefStore.get('refList', refList => {
+      if (refList) {
+        refList.forEach(accRef => {
+          accRef.forEach(acc => {
+            refMap[acc] = [...accRef].filter(r => !(r === acc));
+          });
+        });
+      }
+      callback(refMap);
+    });
+  }
+  addAccountRef(addresses, callback) {
+    this.accountRefStore.get('refList', refList => {
+      const newList = refList ? [...refList] : [];
+      newList.push(addresses);
+      this.accountRefStore.set('refList', newList, callback);
+    });
+  }
+  removeAccountRef(address, callback) {
+    this.accountRefStore.get('refList', refList => {
+      if (refList) {
+        refList.forEach(accRef => {
+          if (accRef.indexOf(address) > -1) {
+            accRef.splice(accRef.indexOf(address), 1);
+          }
+          if (accRef.length < 2) {
+            refList.splice(refList.indexOf(accRef), 1);
+          }
+        });
+        this.accountRefStore.set('refList', refList, () => {
+          callback();
+        });
+      } else {
+        callback();
+      }
+    });
+  }
+  getStakingReward(update) {
+    update(this.stakingRewardState);
+  }
+  subscribeStakingReward() {
+    return this.stakingRewardSubject;
+  }
+  getCurrentAccount(update) {
+    this.currentAccountStore.get('CurrentAccountInfo', update);
+  }
+  setCurrentAccount(data, callback) {
+    const {
+      address,
+      currentGenesisHash
+    } = data;
+    const result = {
+      ...data
+    };
+    if (address === ALL_ACCOUNT_KEY) {
+      const pairs = keyring.getPairs();
+      const pair = pairs[0];
+      const pairGenesisHash = pair.meta.genesisHash;
+      if (pairs.length > 1 || !pair) {
+        result.allGenesisHash = currentGenesisHash || undefined;
+      } else {
+        result.address = pair.address;
+        result.currentGenesisHash = pairGenesisHash || '';
+        result.allGenesisHash = pairGenesisHash || undefined;
+      }
+    }
+    this.currentAccountStore.set('CurrentAccountInfo', result, () => {
+      this.updateServiceInfo();
+      callback && callback();
+    });
+  }
+  setAccountTie(address, genesisHash) {
+    if (address !== ALL_ACCOUNT_KEY) {
+      const pair = keyring.getPair(address);
+      assert(pair, 'Unable to find pair');
+      keyring.saveAccountMeta(pair, {
+        ...pair.meta,
+        genesisHash
+      });
+    }
+    this.getCurrentAccount(accountInfo => {
+      if (address === accountInfo.address) {
+        accountInfo.currentGenesisHash = genesisHash || ALL_GENESIS_HASH;
+        this.setCurrentAccount(accountInfo);
+      }
+    });
+    return true;
+  }
+  async switchEvmNetworkByUrl(shortenUrl, networkKey) {
+    const authUrls = await this.getAuthList();
+    const chainInfo = this.chainService.getChainInfoByKey(networkKey);
+    const chainState = this.chainService.getChainStateByKey(networkKey);
+    if (authUrls[shortenUrl]) {
+      if (chainInfo && !_isChainEnabled(chainState)) {
+        this.enableChain(networkKey);
+      }
+      authUrls[shortenUrl].currentEvmNetworkKey = networkKey;
+      this.setAuthorize(authUrls);
+    } else {
+      throw new EvmProviderError(EvmProviderErrorType.INTERNAL_ERROR, `Not found ${shortenUrl} in auth list`);
+    }
+  }
+  async switchNetworkAccount(id, url, networkKey, changeAddress) {
+    const chainInfo = this.chainService.getChainInfoByKey(networkKey);
+    const chainState = this.chainService.getChainStateByKey(networkKey);
+    const {
+      address,
+      currentGenesisHash
+    } = await new Promise(resolve => {
+      this.getCurrentAccount(resolve);
+    });
+    return this.requestService.addConfirmation(id, url, 'switchNetworkRequest', {
+      networkKey,
+      address: changeAddress
+    }, {
+      address: changeAddress
+    }).then(({
+      isApproved
+    }) => {
+      if (isApproved) {
+        const useAddress = changeAddress || address;
+        if (chainInfo && !_isChainEnabled(chainState)) {
+          this.enableChain(networkKey);
+        }
+        if (useAddress !== ALL_ACCOUNT_KEY) {
+          const pair = keyring.getPair(useAddress);
+          assert(pair, 'Unable to find pair');
+          keyring.saveAccountMeta(pair, {
+            ...pair.meta,
+            genesisHash: _getSubstrateGenesisHash(chainInfo)
+          });
+        }
+        if (address !== changeAddress || _getSubstrateGenesisHash(chainInfo) !== currentGenesisHash || isApproved) {
+          this.setCurrentAccount({
+            address: useAddress,
+            currentGenesisHash: _getSubstrateGenesisHash(chainInfo)
+          });
+        }
+      }
+      return isApproved;
+    });
+  }
+  async addNetworkConfirm(id, url, networkData) {
+    return this.requestService.addConfirmation(id, url, 'addNetworkRequest', networkData).then(({
+      isApproved
+    }) => {
+      if (isApproved) {
+        this.chainService.upsertChain(networkData);
+        return null;
+      } else {
+        throw new EvmProviderError(EvmProviderErrorType.USER_REJECTED_REQUEST);
+      }
+    });
+  }
+  async addTokenConfirm(id, url, tokenInfo) {
+    return this.requestService.addConfirmation(id, url, 'addTokenRequest', tokenInfo).then(({
+      isApproved
+    }) => {
+      if (isApproved) {
+        this.chainService.upsertCustomToken({
+          originChain: tokenInfo.originChain,
+          slug: '',
+          name: tokenInfo.name,
+          symbol: tokenInfo.symbol,
+          decimals: tokenInfo.decimals,
+          priceId: null,
+          minAmount: null,
+          assetType: tokenInfo.type,
+          metadata: _parseMetadataForSmartContractAsset(tokenInfo.contractAddress),
+          multiChainAsset: null,
+          hasValue: _isChainTestNet(this.chainService.getChainInfoByKey(tokenInfo.originChain))
+        });
+        return isApproved;
+      } else {
+        throw new EvmProviderError(EvmProviderErrorType.USER_REJECTED_REQUEST);
+      }
+    });
+  }
+  get metaSubject() {
+    return this.requestService.metaSubject;
+  }
+  get signSubject() {
+    return this.requestService.signSubject;
+  }
+  getSettings(callback) {
+    this.settingService.getSettings(callback);
+  }
+  setSettings(settings, callback) {
+    this.settingService.setSettings(settings, callback);
+  }
+  setTheme(theme, callback) {
+    this.settingService.getSettings(settings => {
+      const newSettings = {
+        ...settings,
+        theme
+      };
+      this.settingService.setSettings(newSettings, () => {
+        callback && callback(newSettings);
+      });
+    });
+  }
+  setBrowserConfirmationType(browserConfirmationType, callback) {
+    this.settingService.getSettings(settings => {
+      const newSettings = {
+        ...settings,
+        browserConfirmationType
+      };
+      this.settingService.setSettings(newSettings, () => {
+        callback && callback(newSettings);
+      });
+    });
+  }
+  subscribeSettingsSubject() {
+    return this.settingService.getSubject();
+  }
+  subscribeCurrentAccount() {
+    return this.currentAccountStore.getSubject();
+  }
+  getAccountAddress() {
+    return new Promise((resolve, reject) => {
+      this.getCurrentAccount(account => {
+        if (account) {
+          resolve(account.address);
+        } else {
+          resolve(null);
+        }
+      });
+    });
+  }
+  async getDecodedAddresses(address) {
+    let checkingAddress = address;
+    if (!address) {
+      checkingAddress = await this.getAccountAddress();
+    }
+    if (!checkingAddress) {
+      return [];
+    }
+    if (checkingAddress === ALL_ACCOUNT_KEY) {
+      return Object.keys(accounts.subject.value);
+    }
+    return [checkingAddress];
+  }
+  getAllAddresses() {
+    return Object.keys(accounts.subject.value);
+  }
+  removeInactiveChainBalances(balanceMap) {
+    const activeBalanceMap = {};
+    Object.entries(balanceMap).forEach(([tokenSlug, balanceItem]) => {
+      const tokenInfo = this.chainService.getAssetBySlug(tokenSlug);
+      if (tokenInfo) {
+        const chainInfo = this.chainService.getChainInfoByKey(tokenInfo.originChain);
+        if (chainInfo && this.getChainStateByKey(chainInfo.slug).active) {
+          activeBalanceMap[tokenSlug] = balanceItem;
+        }
+      }
+    });
+    return activeBalanceMap;
+  }
+  getBalance(reset) {
+    const activeData = this.removeInactiveChainBalances(this.balanceMap);
+    return {
+      details: activeData,
+      reset
+    };
+  }
+  async getStoredBalance(address) {
+    const items = await this.dbService.stores.balance.getBalanceMapByAddress(address);
+    return items || {};
+  }
+  async switchAccount(newAddress) {
+    await Promise.all([this.resetBalanceMap(newAddress), this.resetCrowdloanMap(newAddress)]);
+  }
+  async resetBalanceMap(newAddress) {
+    const defaultData = this.generateDefaultBalanceMap();
+    let storedData = await this.getStoredBalance(newAddress);
+    storedData = this.removeInactiveChainBalances(storedData);
+    this.balanceMap = {
+      ...defaultData,
+      ...storedData
+    };
+    this.publishBalance(true);
+  }
+  async resetCrowdloanMap(newAddress) {
+    const defaultData = generateDefaultCrowdloanMap();
+    const storedData = await this.getStoredCrowdloan(newAddress);
+    this.crowdloanMap = {
+      ...defaultData,
+      ...storedData
+    };
+    this.publishCrowdloan(true);
+  }
+  async resetStaking(newAddress) {
+    this.getStaking().then(data => {
+      this.stakingSubject.next(data);
+    }).catch(e => this.logger.warn(e));
+    const addresses = await this.getDecodedAddresses(newAddress);
+    this.dbService.subscribeStaking(addresses, this.activeChainSlugs, stakings => {
+      this.stakingSubject.next({
+        ready: true,
+        details: stakings
+      });
+    });
+  }
+  setBalanceItem(tokenSlug, item) {
+    this.balanceMap[tokenSlug] = {
+      timestamp: +new Date(),
+      ...item
+    };
+    this.updateBalanceStore(item);
+    this.lazyNext('setBalanceItem', () => {
+      this.publishBalance();
+    });
+  }
+  updateBalanceStore(item) {
+    this.getCurrentAccount(currentAccountInfo => {
+      this.dbService.updateBalanceStore(currentAccountInfo.address, item).catch(e => this.logger.warn(e));
+    });
+  }
+  subscribeBalance() {
+    return this.balanceSubject;
+  }
+  getCrowdloan(reset) {
+    return {
+      details: this.crowdloanMap,
+      reset
+    };
+  }
+  async getStoredCrowdloan(address) {
+    const items = await this.dbService.stores.crowdloan.getDataByAddressAsObject(address);
+    return items || {};
+  }
+  setCrowdloanItem(networkKey, item) {
+    const itemData = {
+      ...item,
+      timestamp: +new Date()
+    };
+
+    // Update crowdloan map
+    this.crowdloanMap[networkKey] = itemData;
+    this.updateCrowdloanStore(networkKey, itemData);
+    this.lazyNext('setCrowdloanItem', () => {
+      this.publishCrowdloan();
+    });
+  }
+  updateCrowdloanStore(networkKey, item) {
+    this.getCurrentAccount(currentAccountInfo => {
+      this.dbService.updateCrowdloanStore(networkKey, currentAccountInfo.address, item).catch(e => this.logger.warn(e));
+    });
+  }
+  subscribeCrowdloan() {
+    return this.crowdloanSubject;
+  }
+  getAllPriceIds() {
+    return this.chainService.getAllPriceIds();
+  }
+  setAssetSettings(assetSettings) {
+    this.assetSettingStore.set('AssetSetting', assetSettings);
+  }
+  getAssetSettings(update) {
+    this.assetSettingStore.get('AssetSetting', rs => {
+      update(rs);
+    });
+  }
+  updateAssetSetting(assetSlug, assetSetting) {
+    this.assetSettingStore.get('AssetSetting', currentAssetSettings => {
+      this.assetSettingStore.set('AssetSetting', {
+        ...currentAssetSettings,
+        [assetSlug]: assetSetting
+      });
+    });
+
+    // if chain not enabled, then automatically enable
+    if (assetSetting.visible) {
+      const assetInfo = this.chainService.getAssetBySlug(assetSlug);
+      this.chainService.enableChain(assetInfo.originChain);
+    }
+  }
+  subscribeAssetSettings() {
+    return this.assetSettingStore.getSubject();
+  }
+  getSmartContractNfts() {
+    return this.chainService.getSmartContractNfts();
+  }
+
+  // ChainService ------------------------------------------------
+
+  getChainInfoMap() {
+    return this.chainService.getChainInfoMap();
+  }
+  getChainStateMap() {
+    return this.chainService.getChainStateMap();
+  }
+  getAssetRefMap() {
+    return this.chainService.getAssetRefMap();
+  }
+  getChainStateByKey(key) {
+    return this.chainService.getChainStateByKey(key);
+  }
+  getAssetRegistry() {
+    return this.chainService.getAssetRegistry();
+  }
+  getMultiChainAssetMap() {
+    return this.chainService.getMultiChainAssetMap();
+  }
+  getAssetByChainAndAsset(chain, assetTypes) {
+    return this.chainService.getAssetByChainAndType(chain, assetTypes);
+  }
+  getAssetBySlug(slug) {
+    return this.chainService.getAssetBySlug(slug);
+  }
+  getXcmEqualAssetByChain(destinationChain, originTokenSlug) {
+    return this.chainService.getXcmEqualAssetByChain(destinationChain, originTokenSlug);
+  }
+  subscribeChainInfoMap() {
+    return this.chainService.subscribeChainInfoMap();
+  }
+  subscribeChainStateMap() {
+    return this.chainService.subscribeChainStateMap();
+  }
+  subscribeAssetRegistry() {
+    return this.chainService.subscribeAssetRegistry();
+  }
+  subscribeMultiChainAssetMap() {
+    return this.chainService.subscribeMultiChainAssetMap();
+  }
+  upsertCustomToken(data) {
+    const tokenSlug = this.chainService.upsertCustomToken(data);
+    if (_isAssetFungibleToken(data)) {
+      this.updateAssetSetting(tokenSlug, {
+        visible: true
+      });
+    }
+    this.updateServiceInfo();
+  }
+  deleteCustomAssets(targetTokens) {
+    this.chainService.deleteCustomAssets(targetTokens);
+    this.updateServiceInfo();
+  }
+  async validateCustomChain(provider, existedChainSlug) {
+    return await this.chainService.validateCustomChain(provider, existedChainSlug);
+  }
+  getSupportedSmartContractTypes() {
+    return this.chainService.getSupportedSmartContractTypes();
+  }
+  async validateCustomAsset(data) {
+    return await this.chainService.validateCustomToken(data);
+  }
+
+  // ------------------------------------------------
+
+  getActiveChainInfoMap() {
+    return this.chainService.getActiveChainInfoMap();
+  }
+  upsertChainInfo(data) {
+    const newNativeTokenSlug = this.chainService.upsertChain(data);
+    if (newNativeTokenSlug) {
+      this.updateAssetSetting(newNativeTokenSlug, {
+        visible: true
+      });
+    }
+    this.updateServiceInfo();
+    return true;
+  }
+  removeCustomChain(networkKey) {
+    const result = this.chainService.removeCustomChain(networkKey);
+    this.updateServiceInfo();
+    return result;
+  }
+
+  // TODO: avoids turning off chains related to ledger account
+  getDefaultNetworkKeys = () => {
+    const genesisHashes = {};
+    const pairs = keyring.getPairs();
+    pairs.forEach(pair => {
+      const originGenesisHash = pair.meta.originGenesisHash;
+      if (originGenesisHash && typeof originGenesisHash === 'string') {
+        genesisHashes[originGenesisHash] = originGenesisHash;
+      }
+    });
+    const hashes = Object.keys(genesisHashes);
+    const result = [];
+    for (const [key, network] of Object.entries(this.chainService.getChainInfoMap())) {
+      const condition = hashes.includes(_getSubstrateGenesisHash(network) || '');
+      if (condition) {
+        result.push(key);
+      }
+    }
+    return result;
+  };
+  updateAssetSettingByChain(chainSlug, visible) {
+    this.assetSettingStore.get('AssetSetting', storedAssetSettings => {
+      const assetsByChain = this.chainService.getFungibleTokensByChain(chainSlug);
+      const assetSettings = storedAssetSettings || {};
+      Object.values(assetsByChain).forEach(assetInfo => {
+        assetSettings[assetInfo.slug] = {
+          visible
+        };
+      });
+      this.setAssetSettings(assetSettings);
+    });
+  }
+  disableChain(chainSlug) {
+    // const defaultChains = this.getDefaultNetworkKeys();
+    this.updateAssetSettingByChain(chainSlug, false);
+    const result = this.chainService.disableChain(chainSlug);
+    this.updateServiceInfo();
+    return result;
+  }
+  enableChain(chainSlug, enableTokens = true) {
+    if (enableTokens) {
+      this.updateAssetSettingByChain(chainSlug, true);
+    }
+    const result = this.chainService.enableChain(chainSlug);
+    this.updateServiceInfo();
+    return result;
+  }
+  resetDefaultChains() {
+    const defaultChains = this.getDefaultNetworkKeys();
+    return this.chainService.resetChainInfoMap(defaultChains);
+  }
+  updateNetworkStatus(networkKey, status) {
+    const chainState = this.chainService.getChainStateByKey(networkKey);
+    if (chainState.connectionStatus === status) {
+      return;
+    }
+    this.chainService.setChainConnectionStatus(networkKey, status);
+  }
+  getSubstrateApiMap() {
+    return this.chainService.getSubstrateApiMap();
+  }
+  getSubstrateApi(networkKey) {
+    return this.chainService.getSubstrateApi(networkKey);
+  }
+  getEvmApiMap() {
+    return this.chainService.getEvmApiMap();
+  }
+  getEvmApi(networkKey) {
+    return this.chainService.getEvmApi(networkKey);
+  }
+  getApiMap() {
+    return {
+      substrate: this.chainService.getSubstrateApiMap(),
+      evm: this.chainService.getEvmApiMap()
+    };
+  }
+  refreshSubstrateApi(key) {
+    this.chainService.refreshSubstrateApi(key);
+    return true;
+  }
+  refreshWeb3Api(key) {
+    this.chainService.refreshEvmApi(key);
+  }
+  subscribeServiceInfo() {
+    return this.serviceInfoSubject;
+  }
+  updateServiceInfo() {
+    this.logger.log('<---Update serviceInfo--->');
+    this.getCurrentAccount(value => {
+      this.serviceInfoSubject.next({
+        chainInfoMap: this.chainService.getChainInfoMap(),
+        chainApiMap: this.getApiMap(),
+        currentAccountInfo: value,
+        assetRegistry: this.chainService.getAssetRegistry(),
+        chainStateMap: this.chainService.getChainStateMap()
+      });
+    });
+  }
+  getExternalRequestMap() {
+    return this.externalRequest;
+  }
+  setExternalRequestMap(id, value) {
+    this.externalRequest[id] = value;
+  }
+  getExternalRequest(id) {
+    return this.externalRequest[id];
+  }
+  updateExternalRequest(id, value) {
+    const rs = this.externalRequest[id];
+    if (rs) {
+      for (const [_key, _value] of Object.entries(value)) {
+        // @ts-ignore
+        rs[_key] = _value;
+      }
+    }
+  }
+  cleanExternalRequest() {
+    const now = new Date().getTime();
+    const map = this.externalRequest;
+    const arr = [];
+    const handlerPushToDelete = (key, value) => {
+      arr.push(key);
+      value.resolve = undefined;
+      value.reject = undefined;
+    };
+    for (const [key, value] of Object.entries(map)) {
+      if (value.status === ExternalRequestPromiseStatus.COMPLETED || value.status === ExternalRequestPromiseStatus.REJECTED) {
+        handlerPushToDelete(key, value);
+      } else {
+        if (now - value.createdAt > 15 * 60 * 60) {
+          handlerPushToDelete(key, value);
+        }
+      }
+    }
+    for (const key of arr) {
+      delete map[key];
+    }
+  }
+  pauseAllNetworks(code, reason) {
+    return this.chainService.stopAllChainApis();
+  }
+  async resumeAllNetworks() {
+    return this.chainService.resumeAllChainApis();
+  }
+  publishBalance(reset) {
+    this.balanceSubject.next(this.getBalance(reset));
+  }
+  publishCrowdloan(reset) {
+    this.crowdloanSubject.next(this.getCrowdloan(reset));
+  }
+
+  // private publishHistory () {
+  //   this.historySubject.next(this.getHistoryMap());
+  // }
+
+  // private removeInactiveDataByChain<T> (data: Record<string, T>) {
+  //   const activeData: Record<string, T> = {};
+  //
+  //   Object.entries(data).forEach(([networkKey, items]) => {
+  //     if (this.chainService.getChainStateByKey(networkKey).active) {
+  //       activeData[networkKey] = items;
+  //     }
+  //   });
+  //
+  //   return activeData;
+  // }
+
+  findNetworkKeyByGenesisHash(genesisHash) {
+    if (!genesisHash) {
+      return [undefined, undefined];
+    }
+    const rs = Object.entries(this.chainService.getChainInfoMap()).find(([networkKey, chainInfo]) => _getSubstrateGenesisHash(chainInfo) === genesisHash);
+    if (rs) {
+      return rs;
+    } else {
+      return [undefined, undefined];
+    }
+  }
+  findChainIdGenesisHash(genesisHash) {
+    const chainInfo = this.findNetworkKeyByGenesisHash(genesisHash)[1];
+    return chainInfo ? _getEvmChainId(chainInfo) : undefined;
+  }
+  findNetworkKeyByChainId(chainId) {
+    if (!chainId) {
+      return [undefined, undefined];
+    }
+    const rs = Object.entries(this.chainService.getChainInfoMap()).find(([networkKey, chainInfo]) => _getEvmChainId(chainInfo) === chainId);
+    if (rs) {
+      return rs;
+    } else {
+      return [undefined, undefined];
+    }
+  }
+  findSingleMode(genesisHash) {
+    const [networkKey] = this.findNetworkKeyByGenesisHash(genesisHash);
+    if (!networkKey) {
+      return undefined;
+    }
+    return Object.values(_PREDEFINED_SINGLE_MODES).find(item => item.networkKeys.includes(networkKey));
+  }
+  accountExportPrivateKey({
+    address,
+    password
+  }) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    const exportedJson = keyring.backupAccount(keyring.getPair(address), password);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    const decoded = decodePair(password, base64Decode(exportedJson.encoded), exportedJson.encoding.type);
+    return {
+      privateKey: u8aToHex(decoded.secretKey),
+      publicKey: u8aToHex(decoded.publicKey)
+    };
+  }
+  checkPublicAndSecretKey({
+    publicKey,
+    secretKey
+  }) {
+    try {
+      const _secret = hexStripPrefix(secretKey);
+      if (_secret.length === 64) {
+        const suri = `0x${_secret}`;
+        const {
+          phrase
+        } = keyExtractSuri(suri);
+        if (isHex(phrase) && isHex(phrase, 256)) {
+          const type = 'ethereum';
+          const address = keyring.createFromUri(getSuri(suri, type), {}, type).address;
+          return {
+            address: address,
+            isValid: true,
+            isEthereum: true
+          };
+        } else {
+          return {
+            address: '',
+            isValid: false,
+            isEthereum: true
+          };
+        }
+      }
+      const keyPair = keyring.keyring.addFromPair({
+        publicKey: hexToU8a(publicKey),
+        secretKey: hexToU8a(secretKey)
+      });
+      return {
+        address: keyPair.address,
+        isValid: true,
+        isEthereum: false
+      };
+    } catch (e) {
+      console.error(e);
+      return {
+        address: '',
+        isValid: false,
+        isEthereum: false
+      };
+    }
+  }
+  getEthKeyring(address, password) {
+    return new Promise(resolve => {
+      const {
+        privateKey
+      } = this.accountExportPrivateKey({
+        address,
+        password: password
+      });
+      const ethKeyring = new SimpleKeyring([privateKey]);
+      resolve(ethKeyring);
+    });
+  }
+  async evmSign(id, url, method, params, allowedAccounts) {
+    let address = '';
+    let payload;
+    const [p1, p2] = params;
+    if (typeof p1 === 'string' && isEthereumAddress(p1)) {
+      address = p1;
+      payload = p2;
+    } else if (typeof p2 === 'string' && isEthereumAddress(p2)) {
+      address = p2;
+      payload = p1;
+    }
+    if (address === '' || !payload) {
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Not found address or payload to sign');
+    }
+    if (['eth_sign', 'personal_sign', 'eth_signTypedData', 'eth_signTypedData_v1', 'eth_signTypedData_v3', 'eth_signTypedData_v4'].indexOf(method) < 0) {
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Not found sign method');
+    }
+    if (['eth_signTypedData_v3', 'eth_signTypedData_v4'].indexOf(method) > -1) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument,@typescript-eslint/no-unsafe-assignment
+      payload = JSON.parse(payload);
+    }
+
+    // Check sign abiblity
+    if (!allowedAccounts.find(acc => acc.toLowerCase() === address.toLowerCase())) {
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Account ' + address + ' not in allowed list');
+    }
+    const pair = keyring.getPair(address);
+    if (!pair) {
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Cannot find pair with address: ' + address);
+    }
+    const account = {
+      address: pair.address,
+      ...pair.meta
+    };
+    let qrPayload = '';
+    let canSign = false;
+    switch (method) {
+      case 'personal_sign':
+        canSign = true;
+        qrPayload = payload;
+        break;
+      case 'eth_sign':
+      case 'eth_signTypedData':
+      case 'eth_signTypedData_v1':
+      case 'eth_signTypedData_v3':
+      case 'eth_signTypedData_v4':
+        if (!account.isExternal) {
+          canSign = true;
+        }
+        break;
+      default:
+        throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Not found sign method');
+    }
+    const signPayload = {
+      account: account,
+      type: method,
+      payload: payload,
+      hashPayload: qrPayload,
+      canSign: canSign,
+      id
+    };
+    return this.requestService.addConfirmation(id, url, 'evmSignatureRequest', signPayload, {
+      requiredPassword: false,
+      address
+    }).then(({
+      isApproved,
+      payload
+    }) => {
+      if (isApproved) {
+        if (payload) {
+          return payload;
+        } else {
+          throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Not found signature');
+        }
+      } else {
+        throw new EvmProviderError(EvmProviderErrorType.USER_REJECTED_REQUEST);
+      }
+    });
+  }
+  async evmSendTransaction(id, url, networkKey, allowedAccounts, transactionParams) {
+    const evmApi = this.getEvmApi(networkKey);
+    const evmNetwork = this.getChainInfo(networkKey);
+    const web3 = evmApi.api;
+    const autoFormatNumber = val => {
+      if (typeof val === 'string' && val.startsWith('0x')) {
+        return new BN(val.replace('0x', ''), 16).toString();
+      } else if (typeof val === 'number') {
+        return val.toString();
+      }
+      return val;
+    };
+    if (transactionParams.from === transactionParams.to) {
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'From address and to address must not be the same');
+    }
+    const transaction = {
+      from: transactionParams.from,
+      to: transactionParams.to,
+      value: autoFormatNumber(transactionParams.value),
+      gasPrice: autoFormatNumber(transactionParams.gasPrice),
+      maxPriorityFeePerGas: autoFormatNumber(transactionParams.maxPriorityFeePerGas),
+      maxFeePerGas: autoFormatNumber(transactionParams.maxFeePerGas),
+      data: transactionParams.data
+    };
+
+    // Calculate transaction data
+    try {
+      transaction.gas = await web3.eth.estimateGas({
+        ...transaction
+      });
+    } catch (e) {
+      // @ts-ignore
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, e === null || e === void 0 ? void 0 : e.message);
+    }
+    const gasPrice = await web3.eth.getGasPrice();
+    transaction.gasPrice = gasPrice;
+    const estimateGas = new BN(gasPrice.toString()).mul(new BN(transaction.gas)).toString();
+
+    // Address is validated in before step
+    const fromAddress = allowedAccounts.find(account => account.toLowerCase() === transaction.from.toLowerCase());
+    if (!fromAddress) {
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'From address is not in available for ' + url);
+    }
+    const pair = keyring.getPair(fromAddress);
+    if (!pair) {
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Cannot find pair with address: ' + fromAddress);
+    }
+    const account = {
+      address: pair.address,
+      ...pair.meta
+    };
+
+    // Validate balance
+    const balance = new BN((await web3.eth.getBalance(fromAddress)) || 0);
+    if (balance.lt(new BN(gasPrice.toString()).mul(new BN(transaction.gas)).add(new BN(autoFormatNumber(transactionParams.value) || '0')))) {
+      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'Balance can be not enough to send transaction');
+    }
+    transaction.nonce = await web3.eth.getTransactionCount(fromAddress);
+    const hashPayload = this.transactionService.generateHashPayload(networkKey, transaction);
+    const isToContract = await isContractAddress(transaction.to || '', evmApi);
+    const parseData = isToContract ? transaction.data ? (await parseContractInput(transaction.data, transaction.to || '', evmNetwork)).result : '' : transaction.data || '';
+    const requestPayload = {
+      ...transaction,
+      estimateGas,
+      hashPayload,
+      isToContract,
+      parseData: parseData,
+      account: account,
+      canSign: true
+    };
+
+    // Todo: Convert this to handle transaction
+    const transactionEmitter = await this.transactionService.addTransaction({
+      transaction: requestPayload,
+      address: requestPayload.from,
+      chain: networkKey,
+      url,
+      data: {
+        ...transaction
+      },
+      extrinsicType: transaction.value ? ExtrinsicType.TRANSFER_BALANCE : ExtrinsicType.EVM_EXECUTE,
+      chainType: ChainType.EVM
+    });
+
+    // Wait extrinsic hash
+    return new Promise((resolve, reject) => {
+      transactionEmitter.on('extrinsicHash', rs => {
+        resolve(rs.extrinsicHash);
+      });
+
+      // Mapping error for evmProvider
+      transactionEmitter.on('error', rs => {
+        var _rs$errors$;
+        let evmProviderError = new EvmProviderError(EvmProviderErrorType.INTERNAL_ERROR);
+        const errorType = ((_rs$errors$ = rs.errors[0]) === null || _rs$errors$ === void 0 ? void 0 : _rs$errors$.errorType) || BasicTxErrorType.INTERNAL_ERROR;
+        if (errorType === BasicTxErrorType.USER_REJECT_REQUEST || errorType === BasicTxErrorType.UNABLE_TO_SIGN) {
+          evmProviderError = new EvmProviderError(EvmProviderErrorType.USER_REJECTED_REQUEST);
+        } else if (errorType === BasicTxErrorType.UNABLE_TO_SEND) {
+          var _rs$errors$2;
+          evmProviderError = new EvmProviderError(EvmProviderErrorType.INTERNAL_ERROR, (_rs$errors$2 = rs.errors[0]) === null || _rs$errors$2 === void 0 ? void 0 : _rs$errors$2.message);
+        }
+        reject(evmProviderError);
+      });
+    });
+  }
+  getConfirmationsQueueSubject() {
+    return this.requestService.confirmationsQueueSubject;
+  }
+  async completeConfirmation(request) {
+    return await this.requestService.completeConfirmation(request);
+  }
+  onInstall() {
+    const singleModes = Object.values(_PREDEFINED_SINGLE_MODES);
+    const setUpSingleMode = ({
+      networkKeys,
+      theme
+    }) => {
+      networkKeys.forEach(key => {
+        this.enableChain(key);
+      });
+      const chainInfo = this.chainService.getChainInfoByKey(networkKeys[0]);
+      const genesisHash = _getSubstrateGenesisHash(chainInfo);
+      this.setCurrentAccount({
+        address: ALL_ACCOUNT_KEY,
+        currentGenesisHash: genesisHash.length > 0 ? genesisHash : null
+      });
+      this.setTheme(theme);
+    };
+    chrome.tabs.query({}, function (tabs) {
+      const openingUrls = tabs.map(t => t.url);
+      const singleMode = singleModes.find(({
+        autoTriggerDomain
+      }) => {
+        const urlRegex = new RegExp(autoTriggerDomain);
+        return Boolean(openingUrls.find(url => {
+          return url && urlRegex.test(url);
+        }));
+      });
+      if (singleMode) {
+        // Wait for everything is ready before enable single mode
+        setTimeout(() => {
+          setUpSingleMode(singleMode);
+        }, 999);
+      }
+    });
+  }
+  get activeNetworks() {
+    return this.chainService.getActiveChainInfos();
+  }
+  get activeChainSlugs() {
+    return Object.values(this.activeNetworks).map(chainInfo => {
+      return chainInfo.slug;
+    });
+  }
+  async sleep() {
+    this.cron.stop();
+    this.subscription.stop();
+    await this.pauseAllNetworks(undefined, 'IDLE mode');
+  }
+  async wakeup() {
+    await this.resumeAllNetworks();
+    this.cron.start();
+    this.subscription.start();
+  }
+  cancelSubscription(id) {
+    if (isSubscriptionRunning(id)) {
+      unsubscribe(id);
+    }
+    if (this.unsubscriptionMap[id]) {
+      this.unsubscriptionMap[id]();
+      delete this.unsubscriptionMap[id];
+    }
+    return true;
+  }
+  createUnsubscriptionHandle(id, unsubscribe) {
+    this.unsubscriptionMap[id] = unsubscribe;
+  }
+}