@subwallet/extension-base 1.0.1 → 1.0.2-1

package/koni/background/handlers/State.js

@@ -11,15 +11,18 @@ import { BalanceService } from '@subwallet/extension-base/services/balance-servi
 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 { CurrentAccountStore } from '@subwallet/extension-base/stores';
 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';
@@ -54,15 +57,8 @@ const generateDefaultCrowdloanMap = () => {
 export default class KoniState {
   injectedProviders = new Map();
   unsubscriptionMap = {};
-  currentAccountStore = new CurrentAccountStore();
   accountRefStore = new AccountRefStore();
-  keyringStateSubject = new Subject();
   externalRequest = {};
-  keyringState = {
-    isReady: false,
-    isLocked: true,
-    hasMasterPassword: false
-  };
   serviceInfoSubject = new Subject();
   balanceMap = {};
   balanceSubject = new Subject();
@@ -80,18 +76,20 @@ export default class KoniState {
   };
   lazyMap = {};
   ready = false;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   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.chainService = new ChainService(this.dbService, this.eventService);
     this.settingService = new SettingService();
     this.requestService = new RequestService(this.chainService, this.settingService);
-    this.priceService = new PriceService(this.serviceInfoSubject, this.dbService, this.chainService);
+    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.transactionService = new TransactionService(this.chainService, this.requestService, this.balanceService, this.historyService, this.notificationService, this.dbService);
+    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);
@@ -198,8 +196,10 @@ export default class KoniState {
     await this.chainService.init();
     await this.migrationService.run();
     this.startSubscription();
-    this.updateServiceInfo();
+    this.eventService.emit('chain.ready', true);
     this.onReady();
+    this.onAccountAdd();
+    this.onAccountRemove();
     this.logger.log('Done init state');
   }
   startSubscription() {
@@ -219,15 +219,8 @@ export default class KoniState {
   isReady() {
     return this.ready;
   }
-  getKeyringState() {
-    return this.keyringState;
-  }
-  subscribeKeyringState() {
-    return this.keyringStateSubject;
-  }
-  setKeyringState(data, callback) {
-    this.keyringStateSubject.next(data);
-    this.keyringState = data;
+  updateKeyringState(isReady = true, callback) {
+    this.keyringService.updateKeyringState(isReady);
     callback && callback();
   }
   lazyNext = (key, callback) => {
@@ -285,7 +278,7 @@ export default class KoniState {
     return this.dbService.getNominatorMetadata();
   }
   async getStaking() {
-    const addresses = await this.getDecodedAddresses();
+    const addresses = this.getDecodedAddresses();
     const stakings = await this.dbService.getStakings(addresses, this.activeChainSlugs);
     return {
       ready: true,
@@ -344,12 +337,12 @@ export default class KoniState {
   subscribeNftCollection() {
     return this.dbService.stores.nftCollection.subscribeNftCollection(this.activeChainSlugs);
   }
-  async resetNft(newAddress) {
+  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);
+    const addresses = this.getDecodedAddresses(newAddress);
     this.dbService.subscribeNft(addresses, this.activeChainSlugs, nfts => {
       this.nftSubject.next({
         nftList: nfts,
@@ -368,7 +361,7 @@ export default class KoniState {
     return this.dbService.deleteNftCollection(chain, collectionId);
   }
   async getNft() {
-    const addresses = await this.getDecodedAddresses();
+    const addresses = this.getDecodedAddresses();
     if (!addresses.length) {
       return;
     }
@@ -442,9 +435,6 @@ export default class KoniState {
   subscribeStakingReward() {
     return this.stakingRewardSubject;
   }
-  getCurrentAccount(update) {
-    this.currentAccountStore.get('CurrentAccountInfo', update);
-  }
   setCurrentAccount(data, callback) {
     const {
       address,
@@ -454,7 +444,7 @@ export default class KoniState {
       ...data
     };
     if (address === ALL_ACCOUNT_KEY) {
-      const pairs = keyring.getPairs();
+      const pairs = keyring.getAccounts();
       const pair = pairs[0];
       const pairGenesisHash = pair.meta.genesisHash;
       if (pairs.length > 1 || !pair) {
@@ -465,10 +455,8 @@ export default class KoniState {
         result.allGenesisHash = pairGenesisHash || undefined;
       }
     }
-    this.currentAccountStore.set('CurrentAccountInfo', result, () => {
-      this.updateServiceInfo();
-      callback && callback();
-    });
+    this.keyringService.setCurrentAccount(result);
+    callback && callback();
   }
   setAccountTie(address, genesisHash) {
     if (address !== ALL_ACCOUNT_KEY) {
@@ -479,12 +467,11 @@ export default class KoniState {
         genesisHash
       });
     }
-    this.getCurrentAccount(accountInfo => {
-      if (address === accountInfo.address) {
-        accountInfo.currentGenesisHash = genesisHash || ALL_GENESIS_HASH;
-        this.setCurrentAccount(accountInfo);
-      }
-    });
+    const accountInfo = this.keyringService.currentAccount;
+    if (address === accountInfo.address) {
+      accountInfo.currentGenesisHash = genesisHash || ALL_GENESIS_HASH;
+      this.setCurrentAccount(accountInfo);
+    }
     return true;
   }
   async switchEvmNetworkByUrl(shortenUrl, networkKey) {
@@ -507,9 +494,7 @@ export default class KoniState {
     const {
       address,
       currentGenesisHash
-    } = await new Promise(resolve => {
-      this.getCurrentAccount(resolve);
-    });
+    } = this.keyringService.currentAccount;
     return this.requestService.addConfirmation(id, url, 'switchNetworkRequest', {
       networkKey,
       address: changeAddress
@@ -624,35 +609,28 @@ export default class KoniState {
   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);
-        }
-      });
-    });
+    const address = this.keyringService.currentAccount.address;
+    if (address === '') {
+      return null;
+    }
+    return address;
   }
-  async getDecodedAddresses(address) {
+  getDecodedAddresses(address) {
     let checkingAddress = address;
     if (!address) {
-      checkingAddress = await this.getAccountAddress();
+      checkingAddress = this.getAccountAddress();
     }
     if (!checkingAddress) {
       return [];
     }
     if (checkingAddress === ALL_ACCOUNT_KEY) {
-      return Object.keys(accounts.subject.value);
+      return this.getAllAddresses();
     }
     return [checkingAddress];
   }
   getAllAddresses() {
-    return Object.keys(accounts.subject.value);
+    return keyring.getAccounts().map(account => account.address);
   }
   removeInactiveChainBalances(balanceMap) {
     const activeBalanceMap = {};
@@ -700,11 +678,11 @@ export default class KoniState {
     };
     this.publishCrowdloan(true);
   }
-  async resetStaking(newAddress) {
+  resetStaking(newAddress) {
     this.getStaking().then(data => {
       this.stakingSubject.next(data);
     }).catch(e => this.logger.warn(e));
-    const addresses = await this.getDecodedAddresses(newAddress);
+    const addresses = this.getDecodedAddresses(newAddress);
     this.dbService.subscribeStaking(addresses, this.activeChainSlugs, stakings => {
       this.stakingSubject.next({
         ready: true,
@@ -723,9 +701,8 @@ export default class KoniState {
     });
   }
   updateBalanceStore(item) {
-    this.getCurrentAccount(currentAccountInfo => {
-      this.dbService.updateBalanceStore(currentAccountInfo.address, item).catch(e => this.logger.warn(e));
-    });
+    const currentAccountInfo = this.keyringService.currentAccount;
+    this.dbService.updateBalanceStore(currentAccountInfo.address, item).catch(e => this.logger.warn(e));
   }
   subscribeBalance() {
     return this.balanceSubject;
@@ -754,9 +731,8 @@ export default class KoniState {
     });
   }
   updateCrowdloanStore(networkKey, item) {
-    this.getCurrentAccount(currentAccountInfo => {
-      this.dbService.updateCrowdloanStore(networkKey, currentAccountInfo.address, item).catch(e => this.logger.warn(e));
-    });
+    const currentAccountInfo = this.keyringService.currentAccount;
+    this.dbService.updateCrowdloanStore(networkKey, currentAccountInfo.address, item).catch(e => this.logger.warn(e));
   }
   subscribeCrowdloan() {
     return this.crowdloanSubject;
@@ -821,12 +797,11 @@ export default class KoniState {
       await this.chainService.updateAssetSetting(tokenSlug, {
         visible: true
       });
+      this.eventService.emit('asset.update', tokenSlug);
     }
-    this.updateServiceInfo();
   }
   deleteCustomAssets(targetTokens) {
     this.chainService.deleteCustomAssets(targetTokens);
-    this.updateServiceInfo();
   }
   async validateCustomChain(provider, existedChainSlug) {
     return await this.chainService.validateCustomChain(provider, existedChainSlug);
@@ -850,13 +825,10 @@ export default class KoniState {
         visible: true
       });
     }
-    this.updateServiceInfo();
     return true;
   }
   removeCustomChain(networkKey) {
-    const result = this.chainService.removeCustomChain(networkKey);
-    this.updateServiceInfo();
-    return result;
+    return this.chainService.removeCustomChain(networkKey);
   }
 
   // TODO: avoids turning off chains related to ledger account
@@ -882,17 +854,13 @@ export default class KoniState {
   async disableChain(chainSlug) {
     // const defaultChains = this.getDefaultNetworkKeys();
     await this.chainService.updateAssetSettingByChain(chainSlug, false);
-    const result = this.chainService.disableChain(chainSlug);
-    this.updateServiceInfo();
-    return result;
+    return this.chainService.disableChain(chainSlug);
   }
   async enableChain(chainSlug, enableTokens = true) {
     if (enableTokens) {
       await this.chainService.updateAssetSettingByChain(chainSlug, true);
     }
-    const result = this.chainService.enableChain(chainSlug);
-    this.updateServiceInfo();
-    return result;
+    return this.chainService.enableChain(chainSlug);
   }
   resetDefaultChains() {
     const defaultChains = this.getDefaultNetworkKeys();
@@ -933,17 +901,14 @@ export default class KoniState {
   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()
-      });
-    });
+  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;
@@ -1374,4 +1339,74 @@ export default class KoniState {
   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);
+    });
+  }
 }

package/koni/background/handlers/Tabs.js

@@ -216,31 +216,34 @@ export default class KoniTabs {
         const allAccounts = accountsObservable.subject.getValue();
         const accountList = transformAccountsV2(allAccounts, false, authInfo, 'evm').map(a => a.address);
         let accounts = [];
-        this.#koniState.getCurrentAccount(({
-          address
-        }) => {
-          if (address === ALL_ACCOUNT_KEY || !accountList.includes(address) || getAll) {
-            accounts = accountList;
-          } else if (address && accountList.includes(address)) {
-            accounts = [address];
-          }
-          resolve(accounts);
-        });
+        const address = this.#koniState.keyringService.currentAccount.address;
+        if (address === ALL_ACCOUNT_KEY || !accountList.includes(address) || getAll) {
+          accounts = accountList;
+        } else if (address && accountList.includes(address)) {
+          accounts = [address];
+        }
+        resolve(accounts);
       }).catch(console.error);
     });
   }
   async getEvmState(url) {
-    let currentEvmNetworkKey;
+    let currentChain;
+    let autoActiveChain = false;
     if (url) {
       const authInfo = await this.getAuthInfo(url);
-      currentEvmNetworkKey = authInfo === null || authInfo === void 0 ? void 0 : authInfo.currentEvmNetworkKey;
-    }
-    let currentEvmNetwork = currentEvmNetworkKey ? this.#koniState.getChainInfo(currentEvmNetworkKey) : undefined;
-    if (currentEvmNetworkKey && !this.#koniState.getChainStateByKey(currentEvmNetworkKey).active) {
-      currentEvmNetwork = Object.values(this.#koniState.getChainInfoMap()).find(network => {
-        return network.evmInfo !== null && this.#koniState.getChainStateByKey(network.slug).active;
-      });
+      if (authInfo !== null && authInfo !== void 0 && authInfo.currentEvmNetworkKey) {
+        currentChain = authInfo === null || authInfo === void 0 ? void 0 : authInfo.currentEvmNetworkKey;
+      }
+      if (authInfo !== null && authInfo !== void 0 && authInfo.isAllowed) {
+        autoActiveChain = true;
+      }
     }
+    const currentEvmNetwork = this.#koniState.requestService.getDAppChainInfo({
+      autoActive: autoActiveChain,
+      accessType: 'evm',
+      defaultChain: currentChain,
+      url
+    });
     if (currentEvmNetwork) {
       const {
         evmInfo,
@@ -437,7 +440,7 @@ export default class KoniTabs {
         currentAccountList = newAccountList;
       }
     };
-    const accountListSubscription = this.#koniState.subscribeCurrentAccount().subscribe(() => {
+    const accountListSubscription = this.#koniState.keyringService.currentAccountSubject.subscribe(() => {
       onCurrentAccountChanged().catch(console.error);
     });
 

package/koni/background/subscription.d.ts

@@ -4,7 +4,7 @@ import DatabaseService from '@subwallet/extension-base/services/storage-service/
 import KoniState from './handlers/State';
 declare type SubscriptionName = 'balance' | 'crowdloan' | 'stakingOnChain';
 export declare class KoniSubscription {
-    private serviceSubscription;
+    private eventHandler?;
     private subscriptionMap;
     dbService: DatabaseService;
     private state;

package/koni/background/subscription.js

@@ -10,8 +10,9 @@ import { getRelayChainPoolMemberMetadata } from '@subwallet/extension-base/koni/
 import { getAmplitudeUnclaimedStakingReward } from '@subwallet/extension-base/koni/api/staking/paraChain';
 import { nftHandler } from '@subwallet/extension-base/koni/background/handlers';
 import { _STAKING_CHAIN_GROUP } from '@subwallet/extension-base/services/chain-service/constants';
-import { _isChainEnabled, _isChainSupportSubstrateStaking, _isSubstrateRelayChain } from '@subwallet/extension-base/services/chain-service/utils';
+import { _isChainEnabled, _isChainEvmCompatible, _isChainSupportSubstrateStaking, _isSubstrateRelayChain } from '@subwallet/extension-base/services/chain-service/utils';
 import { logger as createLogger } from '@polkadot/util';
+import { isEthereumAddress } from '@polkadot/util-crypto';
 export class KoniSubscription {
   subscriptionMap = {
     crowdloan: undefined,
@@ -50,19 +51,22 @@ export class KoniSubscription {
     }
   }
   start() {
+    var _this$state$keyringSe;
     this.logger.log('Starting subscription');
-    this.state.getCurrentAccount(currentAccountInfo => {
-      if (currentAccountInfo) {
-        const {
-          address
-        } = currentAccountInfo;
-        this.subscribeBalancesAndCrowdloans(address, this.state.getChainInfoMap(), this.state.getChainStateMap(), this.state.getSubstrateApiMap(), this.state.getEvmApiMap());
-        this.subscribeStakingOnChain(address, this.state.getSubstrateApiMap());
-      }
-    });
-    !this.serviceSubscription && (this.serviceSubscription = this.state.subscribeServiceInfo().subscribe({
-      next: serviceInfo => {
+    const currentAddress = (_this$state$keyringSe = this.state.keyringService.currentAccount) === null || _this$state$keyringSe === void 0 ? void 0 : _this$state$keyringSe.address;
+    if (currentAddress) {
+      this.subscribeBalancesAndCrowdloans(currentAddress, this.state.getChainInfoMap(), this.state.getChainStateMap(), this.state.getSubstrateApiMap(), this.state.getEvmApiMap());
+      this.subscribeStakingOnChain(currentAddress, this.state.getSubstrateApiMap());
+    }
+    if (!this.eventHandler) {
+      const reloadEvents = ['account.add', 'account.remove', 'account.updateCurrent', 'chain.add', 'chain.update', 'chain.enable', 'asset.update', 'asset.enable', 'transaction.done', 'transaction.failed'];
+      this.eventHandler = (events, eventTypes) => {
         var _serviceInfo$currentA;
+        const serviceInfo = this.state.getServiceInfo();
+        const needReload = eventTypes.some(eT => reloadEvents.includes(eT));
+        if (!needReload) {
+          return;
+        }
         this.logger.log('ServiceInfo updated, restarting...');
         const address = (_serviceInfo$currentA = serviceInfo.currentAccountInfo) === null || _serviceInfo$currentA === void 0 ? void 0 : _serviceInfo$currentA.address;
         if (!address) {
@@ -70,14 +74,14 @@ export class KoniSubscription {
         }
         this.subscribeBalancesAndCrowdloans(address, serviceInfo.chainInfoMap, serviceInfo.chainStateMap, serviceInfo.chainApiMap.substrate, serviceInfo.chainApiMap.evm);
         this.subscribeStakingOnChain(address, serviceInfo.chainApiMap.substrate);
-      }
-    }));
+      };
+      this.state.eventService.onLazy(this.eventHandler);
+    }
   }
   stop() {
     this.logger.log('Stopping subscription');
-    if (this.serviceSubscription) {
-      this.serviceSubscription.unsubscribe();
-      this.serviceSubscription = undefined;
+    if (this.eventHandler) {
+      this.state.eventService.offLazy(this.eventHandler);
     }
     this.stopAllSubscription();
   }
@@ -104,24 +108,21 @@ export class KoniSubscription {
   }
   subscribeBalancesAndCrowdloans(address, chainInfoMap, chainStateMap, substrateApiMap, web3ApiMap, onlyRunOnFirstTime) {
     this.state.switchAccount(address).then(() => {
-      this.state.getDecodedAddresses(address).then(addresses => {
-        if (!addresses.length) {
-          return;
-        }
-        this.updateSubscription('balance', this.initBalanceSubscription(addresses, chainInfoMap, chainStateMap, substrateApiMap, web3ApiMap, onlyRunOnFirstTime));
-        this.updateSubscription('crowdloan', this.initCrowdloanSubscription(addresses, substrateApiMap, onlyRunOnFirstTime));
-      }).catch(this.logger.error);
+      const addresses = this.state.getDecodedAddresses(address);
+      if (!addresses.length) {
+        return;
+      }
+      this.updateSubscription('balance', this.initBalanceSubscription(addresses, chainInfoMap, chainStateMap, substrateApiMap, web3ApiMap, onlyRunOnFirstTime));
+      this.updateSubscription('crowdloan', this.initCrowdloanSubscription(addresses, substrateApiMap, onlyRunOnFirstTime));
     }).catch(err => this.logger.warn(err));
   }
   subscribeStakingOnChain(address, substrateApiMap, onlyRunOnFirstTime) {
-    this.state.resetStaking(address).then(() => {
-      this.state.getDecodedAddresses(address).then(addresses => {
-        if (!addresses.length) {
-          return;
-        }
-        this.updateSubscription('stakingOnChain', this.initStakingOnChainSubscription(addresses, substrateApiMap, onlyRunOnFirstTime));
-      }).catch(this.logger.error);
-    }).catch(err => this.logger.warn(err));
+    this.state.resetStaking(address);
+    const addresses = this.state.getDecodedAddresses(address);
+    if (!addresses.length) {
+      return;
+    }
+    this.updateSubscription('stakingOnChain', this.initStakingOnChainSubscription(addresses, substrateApiMap, onlyRunOnFirstTime));
   }
   initStakingOnChainSubscription(addresses, substrateApiMap, onlyRunOnFirstTime) {
     const unsub = stakingOnChainApi(addresses, substrateApiMap, (networkKey, rs) => {
@@ -137,9 +138,9 @@ export class KoniSubscription {
   }
   initBalanceSubscription(addresses, chainInfoMap, chainStateMap, substrateApiMap, evmApiMap, onlyRunOnFirstTime) {
     const filteredChainInfoMap = {};
-    Object.values(chainInfoMap).forEach(chainInfo => {
-      if (chainStateMap[chainInfo.slug].active) {
-        filteredChainInfoMap[chainInfo.slug] = chainInfo;
+    Object.values(chainStateMap).forEach(chainState => {
+      if (chainState.active) {
+        filteredChainInfoMap[chainState.slug] = chainInfoMap[chainState.slug];
       }
     });
     const unsub = subscribeBalance(addresses, filteredChainInfoMap, substrateApiMap, evmApiMap, result => {
@@ -166,12 +167,11 @@ export class KoniSubscription {
     };
   }
   subscribeNft(address, substrateApiMap, evmApiMap, smartContractNfts, chainInfoMap) {
-    this.state.getDecodedAddresses(address).then(addresses => {
-      if (!addresses.length) {
-        return;
-      }
-      this.initNftSubscription(addresses, substrateApiMap, evmApiMap, smartContractNfts, chainInfoMap);
-    }).catch(this.logger.error);
+    const addresses = this.state.getDecodedAddresses(address);
+    if (!addresses.length) {
+      return;
+    }
+    this.initNftSubscription(addresses, substrateApiMap, evmApiMap, smartContractNfts, chainInfoMap);
   }
   initNftSubscription(addresses, substrateApiMap, evmApiMap, smartContractNfts, chainInfoMap) {
     nftHandler.setChainInfoMap(chainInfoMap);
@@ -183,7 +183,7 @@ export class KoniSubscription {
     }).catch(this.logger.log);
   }
   async subscribeStakingReward(address) {
-    const addresses = await this.state.getDecodedAddresses(address);
+    const addresses = this.state.getDecodedAddresses(address);
     if (!addresses.length) {
       return;
     }
@@ -200,7 +200,7 @@ export class KoniSubscription {
     this.logger.log('Set staking reward state done', result);
   }
   async subscribeStakingRewardFastInterval(address) {
-    const addresses = await this.state.getDecodedAddresses(address);
+    const addresses = this.state.getDecodedAddresses(address);
     if (!addresses.length) {
       return;
     }
@@ -249,8 +249,13 @@ export class KoniSubscription {
     if (currentAddress === ALL_ACCOUNT_KEY) {
       addresses = await this.state.getStakingOwnersByChains(Object.keys(filteredChainInfoMap));
     }
-    await Promise.all(addresses.map(async address => {
+    const validAddresses = addresses.filter(address => !isEthereumAddress(address));
+    await Promise.all(validAddresses.map(async address => {
+      const isEvmAddress = isEthereumAddress(address);
       await Promise.all(Object.values(filteredChainInfoMap).map(async chainInfo => {
+        if (isEvmAddress && !_isChainEvmCompatible(chainInfo)) {
+          return;
+        }
         if (_isSubstrateRelayChain(chainInfo) && _STAKING_CHAIN_GROUP.nominationPool.includes(chainInfo.slug)) {
           const poolMemberMetadata = await getRelayChainPoolMemberMetadata(chainInfo, address, substrateApiMap[chainInfo.slug]);
           if (poolMemberMetadata) {