@subwallet/extension-base 0.8.4-0 → 1.0.2-1

package/koni/background/handlers/State.js

@@ -0,0 +1,1412 @@
+// 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 { 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 { EventService } from '@subwallet/extension-base/services/event-service';
+import { HistoryService } from '@subwallet/extension-base/services/history-service';
+import { KeyringService } from '@subwallet/extension-base/services/keyring-service';
+import MigrationService from '@subwallet/extension-base/services/migration-service';
+import NotificationService from '@subwallet/extension-base/services/notification-service/NotificationService';
+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 { SubscanService } from '@subwallet/extension-base/services/subscan-service';
+import { SUBSCAN_CHAIN_MAP_REVERSE } from '@subwallet/extension-base/services/subscan-service/subscan-chain-map';
+import TransactionService from '@subwallet/extension-base/services/transaction-service';
+import AccountRefStore from '@subwallet/extension-base/stores/AccountRef';
+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 = {};
+  accountRefStore = new AccountRefStore();
+  externalRequest = {};
+  serviceInfoSubject = new Subject();
+  balanceMap = {};
+  balanceSubject = new Subject();
+  crowdloanMap = generateDefaultCrowdloanMap();
+  crowdloanSubject = new Subject();
+  nftSubject = new Subject();
+  stakingSubject = new Subject();
+  chainStakingMetadataSubject = new Subject();
+  stakingNominatorMetadataSubject = new Subject();
+  stakingRewardSubject = new Subject();
+  stakingRewardState = {
+    ready: false,
+    slowInterval: [],
+    fastInterval: []
+  };
+  lazyMap = {};
+  ready = false;
+  constructor(providers = {}) {
+    this.providers = providers;
+    this.dbService = new DatabaseService();
+    this.eventService = new EventService();
+    this.subscanService = new SubscanService();
+    this.keyringService = new KeyringService(this.eventService);
+    this.notificationService = new NotificationService();
+    this.chainService = new ChainService(this.dbService, this.eventService);
+    this.settingService = new SettingService();
+    this.requestService = new RequestService(this.chainService, this.settingService);
+    this.priceService = new PriceService(this.dbService, this.eventService, this.chainService);
+    this.balanceService = new BalanceService(this.chainService);
+    this.historyService = new HistoryService(this.dbService, this.chainService, this.eventService);
+    this.transactionService = new TransactionService(this.chainService, this.eventService, this.requestService, this.balanceService, this.historyService, this.notificationService, this.dbService);
+    this.migrationService = new MigrationService(this);
+    this.subscription = new KoniSubscription(this, this.dbService);
+    this.cron = new KoniCron(this, this.subscription, this.dbService);
+    this.logger = createLogger('State');
+
+    // Init state
+    this.init().catch(console.error);
+  }
+
+  // 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);
+  }
+  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;
+  }
+  async init() {
+    await this.chainService.init();
+    await this.migrationService.run();
+    this.startSubscription();
+    this.eventService.emit('chain.ready', true);
+    this.onReady();
+    this.onAccountAdd();
+    this.onAccountRemove();
+    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;
+  }
+  updateKeyringState(isReady = true, callback) {
+    this.keyringService.updateKeyringState(isReady);
+    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 = 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));
+  }
+  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);
+  }
+  resetNft(newAddress) {
+    this.getNft().then(data => this.nftSubject.next(data || {
+      nftList: [],
+      total: 0
+    })).catch(e => this.logger.warn(e));
+    const addresses = 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);
+  }
+  removeNfts(chain, address, collectionId, nftIds) {
+    return this.dbService.removeNfts(chain, address, collectionId, nftIds);
+  }
+  deleteNftCollection(chain, collectionId) {
+    return this.dbService.deleteNftCollection(chain, collectionId);
+  }
+  async getNft() {
+    const addresses = 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;
+  }
+  setCurrentAccount(data, callback) {
+    const {
+      address,
+      currentGenesisHash
+    } = data;
+    const result = {
+      ...data
+    };
+    if (address === ALL_ACCOUNT_KEY) {
+      const pairs = keyring.getAccounts();
+      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.keyringService.setCurrentAccount(result);
+    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
+      });
+    }
+    const accountInfo = this.keyringService.currentAccount;
+    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)) {
+        await 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
+    } = this.keyringService.currentAccount;
+    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).catch(console.error);
+        }
+        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(async ({
+      isApproved
+    }) => {
+      if (isApproved) {
+        await this.upsertChainInfo(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(async ({
+      isApproved
+    }) => {
+      if (isApproved) {
+        await this.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);
+      });
+    });
+  }
+  setCamera(value) {
+    this.settingService.getSettings(settings => {
+      const newSettings = {
+        ...settings,
+        camera: value
+      };
+      console.log(newSettings, value);
+      this.settingService.setSettings(newSettings);
+    });
+  }
+  subscribeSettingsSubject() {
+    return this.settingService.getSubject();
+  }
+  getAccountAddress() {
+    const address = this.keyringService.currentAccount.address;
+    if (address === '') {
+      return null;
+    }
+    return address;
+  }
+  getDecodedAddresses(address) {
+    let checkingAddress = address;
+    if (!address) {
+      checkingAddress = this.getAccountAddress();
+    }
+    if (!checkingAddress) {
+      return [];
+    }
+    if (checkingAddress === ALL_ACCOUNT_KEY) {
+      return this.getAllAddresses();
+    }
+    return [checkingAddress];
+  }
+  getAllAddresses() {
+    return keyring.getAccounts().map(account => account.address);
+  }
+  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);
+  }
+  resetStaking(newAddress) {
+    this.getStaking().then(data => {
+      this.stakingSubject.next(data);
+    }).catch(e => this.logger.warn(e));
+    const addresses = 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) {
+    const currentAccountInfo = this.keyringService.currentAccount;
+    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) {
+    const currentAccountInfo = this.keyringService.currentAccount;
+    this.dbService.updateCrowdloanStore(networkKey, currentAccountInfo.address, item).catch(e => this.logger.warn(e));
+  }
+  subscribeCrowdloan() {
+    return this.crowdloanSubject;
+  }
+  getAllPriceIds() {
+    return this.chainService.getAllPriceIds();
+  }
+  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();
+  }
+  getXcmRefMap() {
+    return this.chainService.getXcmRefMap();
+  }
+  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();
+  }
+  subscribeXcmRefMap() {
+    return this.chainService.subscribeXcmRefMap();
+  }
+  async upsertCustomToken(data) {
+    const tokenSlug = this.chainService.upsertCustomToken(data);
+    if (_isAssetFungibleToken(data)) {
+      await this.chainService.updateAssetSetting(tokenSlug, {
+        visible: true
+      });
+      this.eventService.emit('asset.update', tokenSlug);
+    }
+  }
+  deleteCustomAssets(targetTokens) {
+    this.chainService.deleteCustomAssets(targetTokens);
+  }
+  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();
+  }
+  async upsertChainInfo(data) {
+    const newNativeTokenSlug = this.chainService.upsertChain(data);
+    if (newNativeTokenSlug) {
+      await this.chainService.updateAssetSetting(newNativeTokenSlug, {
+        visible: true
+      });
+    }
+    return true;
+  }
+  removeCustomChain(networkKey) {
+    return this.chainService.removeCustomChain(networkKey);
+  }
+
+  // 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;
+  };
+  async disableChain(chainSlug) {
+    // const defaultChains = this.getDefaultNetworkKeys();
+    await this.chainService.updateAssetSettingByChain(chainSlug, false);
+    return this.chainService.disableChain(chainSlug);
+  }
+  async enableChain(chainSlug, enableTokens = true) {
+    if (enableTokens) {
+      await this.chainService.updateAssetSettingByChain(chainSlug, true);
+    }
+    return this.chainService.enableChain(chainSlug);
+  }
+  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;
+  }
+  getServiceInfo() {
+    return {
+      chainInfoMap: this.chainService.getChainInfoMap(),
+      chainApiMap: this.getApiMap(),
+      currentAccountInfo: this.keyringService.currentAccount,
+      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).catch(console.error);
+      });
+      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;
+  }
+  async autoEnableChains(addresses) {
+    const assetMap = this.chainService.getAssetRegistry();
+    const promiseList = addresses.map(address => {
+      return this.subscanService.getMultiChainBalance(address).catch(e => {
+        console.error(e);
+        return null;
+      });
+    });
+    const needEnableChains = [];
+    const needActiveTokens = [];
+    const currentAssetSettings = await this.chainService.getAssetSettings();
+    const chainMap = this.chainService.getChainInfoMap();
+    const balanceDataList = await Promise.all(promiseList);
+    balanceDataList.forEach(balanceData => {
+      balanceData && balanceData.forEach(({
+        balance,
+        bonded,
+        category,
+        locked,
+        network,
+        symbol
+      }) => {
+        var _currentAssetSettings;
+        const chain = SUBSCAN_CHAIN_MAP_REVERSE[network];
+        const chainInfo = chain ? chainMap[chain] : null;
+        const balanceIsEmpty = (!balance || balance === '0') && !locked && locked === '0' && (!bonded || bonded === '0');
+
+        // Cancel if chain is not supported or is testnet or balance is 0
+        if (!chainInfo || chainInfo.isTestnet || balanceIsEmpty) {
+          return;
+        }
+        const tokenKey = `${chain}-${category === 'native' ? 'NATIVE' : 'LOCAL'}-${symbol.toUpperCase()}`;
+        if (assetMap[tokenKey] && !((_currentAssetSettings = currentAssetSettings[tokenKey]) !== null && _currentAssetSettings !== void 0 && _currentAssetSettings.visible)) {
+          needEnableChains.push(chain);
+          needActiveTokens.push(tokenKey);
+          currentAssetSettings[tokenKey] = {
+            visible: true
+          };
+        }
+      });
+    });
+    if (needActiveTokens.length) {
+      this.chainService.enableChains(needEnableChains);
+      this.chainService.setAssetSettings({
+        ...currentAssetSettings
+      });
+    }
+  }
+  onAccountAdd() {
+    this.eventService.on('account.add', address => {
+      this.autoEnableChains([address]).catch(this.logger.error);
+    });
+  }
+  onAccountRemove() {
+    this.eventService.on('account.remove', address => {
+      // Some separate service like historyService will listen to this event and remove inside that service
+
+      const stores = this.dbService.stores;
+
+      // Remove Balance
+      stores.balance.removeAllByAddress(address).catch(console.error);
+      stores.balance.removeAllByAddress(ALL_ACCOUNT_KEY).catch(console.error);
+
+      // Remove NFT
+      stores.nft.deleteNftByAddress([address]).catch(console.error);
+
+      // Remove Staking Data
+      stores.staking.removeAllByAddress(address).catch(console.error);
+    });
+  }
+}