@subwallet/extension-base 1.0.2-2 → 1.0.3-0

package/cjs/services/chain-service/index.js

@@ -7,8 +7,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.ChainService = void 0;
 var _chainList = require("@subwallet/chain-list");
 var _types = require("@subwallet/chain-list/types");
-var _constants = require("@subwallet/extension-base/constants");
-var _constants2 = require("@subwallet/extension-base/services/chain-service/constants");
+var _constants = require("@subwallet/extension-base/services/chain-service/constants");
 var _EvmChainHandler = require("@subwallet/extension-base/services/chain-service/handler/EvmChainHandler");
 var _SubstrateChainHandler = require("@subwallet/extension-base/services/chain-service/handler/SubstrateChainHandler");
 var _types2 = require("@subwallet/extension-base/services/chain-service/handler/types");
@@ -51,7 +50,7 @@ class ChainService {
     this.multiChainAssetMapSubject.next(_chainList.MultiChainAssetMap);
     this.xcmRefMapSubject.next(this.getXcmRefMap());
     this.logger = (0, _logger.logger)('chain-service');
-    this.refreshChainStateInterval(3000);
+    this.refreshChainStateInterval(3000, 6);
   }
 
   // Getter
@@ -158,7 +157,8 @@ class ChainService {
       priceId: '',
       slug: '',
       symbol: '',
-      hasValue: true
+      hasValue: true,
+      icon: ''
     };
     for (const assetInfo of Object.values(this.getAssetRegistry())) {
       if (assetInfo.assetType === _types._AssetType.NATIVE && assetInfo.originChain === chainSlug) {
@@ -286,7 +286,7 @@ class ChainService {
     this.dbService.removeFromChainStore([slug]).catch(console.error);
     this.updateChainSubscription();
     this.lockChainInfoMap = false;
-    this.eventService.emit('chain.remove', slug);
+    this.eventService.emit('chain.updateState', slug);
     return true;
   }
   resetChainInfoMap(excludedChains) {
@@ -296,7 +296,7 @@ class ChainService {
     this.lockChainInfoMap = true;
     const chainStateMap = this.getChainStateMap();
     for (const [slug, chainState] of Object.entries(chainStateMap)) {
-      if (!_constants2._DEFAULT_ACTIVE_CHAINS.includes(slug) && !(excludedChains !== null && excludedChains !== void 0 && excludedChains.includes(slug))) {
+      if (!_constants._DEFAULT_ACTIVE_CHAINS.includes(slug) && !(excludedChains !== null && excludedChains !== void 0 && excludedChains.includes(slug))) {
         chainState.active = false;
       }
     }
@@ -352,7 +352,7 @@ class ChainService {
     this.dbService.removeFromAssetStore(targetAssets).catch(e => this.logger.error(e));
     this.assetRegistrySubject.next(assetRegistry);
     targetAssets.forEach(assetSlug => {
-      this.eventService.emit('asset.remove', assetSlug);
+      this.eventService.emit('asset.updateState', assetSlug);
     });
   }
 
@@ -419,14 +419,14 @@ class ChainService {
     this.lockChainInfoMap = true;
     chainStateMap[chainSlug].active = true;
     this.initApiForChain(chainInfo);
-    this.refreshChainStateInterval(1000);
+    this.refreshChainStateInterval(3000, 6);
     this.dbService.updateChainStore({
       ...chainInfo,
       active: true,
       currentProvider: chainStateMap[chainSlug].currentProvider
     }).catch(console.error);
     this.lockChainInfoMap = false;
-    this.eventService.emit('chain.enable', chainSlug);
+    this.eventService.emit('chain.updateState', chainSlug);
     return true;
   }
   enableChain(chainSlug) {
@@ -461,7 +461,7 @@ class ChainService {
     }).catch(console.error);
     this.updateChainStateMapSubscription();
     this.lockChainInfoMap = false;
-    this.eventService.emit('chain.disable', chainSlug);
+    this.eventService.emit('chain.updateState', chainSlug);
     return true;
   }
   checkExistedPredefinedChain(genesisHash, evmChainId) {
@@ -497,13 +497,13 @@ class ChainService {
           currentProvider: Object.keys(chainInfo.providers)[0],
           slug: chainInfo.slug,
           connectionStatus: _types3._ChainConnectionStatus.DISCONNECTED,
-          active: _constants2._DEFAULT_ACTIVE_CHAINS.includes(chainInfo.slug)
+          active: _constants._DEFAULT_ACTIVE_CHAINS.includes(chainInfo.slug)
         };
 
         // create data for storage
         newStorageData.push({
           ...chainInfo,
-          active: _constants2._DEFAULT_ACTIVE_CHAINS.includes(chainInfo.slug),
+          active: _constants._DEFAULT_ACTIVE_CHAINS.includes(chainInfo.slug),
           currentProvider: Object.keys(chainInfo.providers)[0]
         });
       });
@@ -559,7 +559,8 @@ class ChainService {
               evmInfo: storedChainInfo.evmInfo,
               substrateInfo: storedChainInfo.substrateInfo,
               isTestnet: storedChainInfo.isTestnet,
-              chainStatus: storedChainInfo.chainStatus
+              chainStatus: storedChainInfo.chainStatus,
+              icon: storedChainInfo.icon
             };
             this.dataMap.chainStateMap[storedSlug] = {
               currentProvider: storedChainInfo.currentProvider,
@@ -584,11 +585,11 @@ class ChainService {
             currentProvider: Object.keys(chainInfo.providers)[0],
             slug,
             connectionStatus: _types3._ChainConnectionStatus.DISCONNECTED,
-            active: _constants2._DEFAULT_ACTIVE_CHAINS.includes(slug)
+            active: _constants._DEFAULT_ACTIVE_CHAINS.includes(slug)
           };
           newStorageData.push({
             ...mergedChainInfoMap[slug],
-            active: _constants2._DEFAULT_ACTIVE_CHAINS.includes(slug),
+            active: _constants._DEFAULT_ACTIVE_CHAINS.includes(slug),
             currentProvider: Object.keys(chainInfo.providers)[0]
           });
         }
@@ -685,7 +686,7 @@ class ChainService {
       active: targetChainState.active,
       currentProvider: targetChainState.currentProvider
     }).then(() => {
-      this.eventService.emit('chain.update', chainSlug);
+      this.eventService.emit('chain.updateState', chainSlug);
     }).catch(e => this.logger.error(e));
   }
   insertChain(params) {
@@ -731,7 +732,8 @@ class ChainService {
       substrateInfo,
       evmInfo,
       isTestnet: false,
-      chainStatus: _types._ChainStatus.ACTIVE
+      chainStatus: _types._ChainStatus.ACTIVE,
+      icon: '' // Todo: Allow update with custom chain
     };
 
     // insert new chainInfo
@@ -759,7 +761,8 @@ class ChainService {
       priceId: params.chainEditInfo.priceId || null,
       slug: '',
       symbol: params.chainEditInfo.symbol,
-      hasValue: true
+      hasValue: true,
+      icon: ''
     });
 
     // update subscription
@@ -974,21 +977,23 @@ class ChainService {
   }
   async validateCustomToken(data) {
     const assetRegistry = this.getSmartContractTokens();
-    let isExist = false;
+    let existedToken;
     for (const token of Object.values(assetRegistry)) {
       var _token$metadata2;
       const contractAddress = token === null || token === void 0 ? void 0 : (_token$metadata2 = token.metadata) === null || _token$metadata2 === void 0 ? void 0 : _token$metadata2.contractAddress;
       if ((0, _utils._isEqualContractAddress)(contractAddress, data.contractAddress) && token.assetType === data.type && token.originChain === data.originChain) {
-        isExist = true;
+        existedToken = token;
         break;
       }
     }
-    if (isExist) {
+    if (existedToken) {
+      var _existedToken;
       return {
-        decimals: -1,
-        name: '',
-        symbol: '',
-        isExist,
+        decimals: existedToken.decimals || 0,
+        name: existedToken.name,
+        symbol: existedToken.symbol,
+        isExist: !!existedToken,
+        existedSlug: (_existedToken = existedToken) === null || _existedToken === void 0 ? void 0 : _existedToken.slug,
         contractError: false
       };
     }
@@ -1002,7 +1007,7 @@ class ChainService {
       name,
       decimals,
       symbol,
-      isExist,
+      isExist: !!existedToken,
       contractError
     };
   }
@@ -1052,20 +1057,28 @@ class ChainService {
 
     return this.substrateChainHandler.resumeAllApis();
   }
-
-  // Interval update api status
+  refreshChainStateTimeout = undefined;
+  refreshChainStateTimes = 0;
   refreshChainStateInterval() {
     let delay = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    let times = arguments.length > 1 ? arguments[1] : undefined;
     clearTimeout(this.refreshChainStateTimeout);
     setTimeout(() => {
-      this.updateApiMapStatus();
+      if (times) {
+        this.refreshChainStateTimes = times;
+      }
+      this.refreshChainStateTimes -= 1;
+      if (this.refreshChainStateTimes < 0) {
+        return;
+      }
+      this.updateApiMapStatus().catch(console.error);
       this.refreshChainStateTimeout = setTimeout(() => {
-        this.updateApiMapStatus();
-        this.refreshChainStateInterval();
-      }, _constants.CRON_GET_API_MAP_STATUS);
+        this.updateApiMapStatus().catch(console.error);
+        this.refreshChainStateInterval(0);
+      }, 3000);
     }, delay);
   }
-  updateApiMapStatus() {
+  async updateApiMapStatus() {
     const substrateApiMap = this.getSubstrateApiMap();
     const evmApiMap = this.getEvmApiMap();
     const chainStateMap = this.getChainStateMap();
@@ -1076,25 +1089,31 @@ class ChainService {
         update = true;
       }
     }
-    Object.entries(chainStateMap).forEach(_ref4 => {
+    const promiseList = Object.entries(chainStateMap).map(async _ref4 => {
       let [chain, chainState] = _ref4;
-      if (chainState.active) {
-        if (substrateApiMap[chain]) {
-          const api = substrateApiMap[chain];
-          if (api) {
-            updateState(chainState, _types3._ChainConnectionStatus.CONNECTED);
-            return;
-          }
-        } else if (evmApiMap[chain]) {
-          const api = evmApiMap[chain];
-          if (api) {
-            updateState(chainState, _types3._ChainConnectionStatus.CONNECTED);
-            return;
+      try {
+        if (chainState.active) {
+          if (substrateApiMap[chain]) {
+            const api = substrateApiMap[chain];
+            if (api.isApiConnected) {
+              updateState(chainState, _types3._ChainConnectionStatus.CONNECTED);
+              return;
+            }
+          } else if (evmApiMap[chain]) {
+            var _api$api;
+            const api = evmApiMap[chain];
+            if (await (api === null || api === void 0 ? void 0 : (_api$api = api.api) === null || _api$api === void 0 ? void 0 : _api$api.eth.net.isListening())) {
+              updateState(chainState, _types3._ChainConnectionStatus.CONNECTED);
+              return;
+            }
           }
         }
+        updateState(chainState, _types3._ChainConnectionStatus.DISCONNECTED);
+      } catch (e) {
+        updateState(chainState, _types3._ChainConnectionStatus.DISCONNECTED);
       }
-      updateState(chainState, _types3._ChainConnectionStatus.DISCONNECTED);
     });
+    await Promise.all(promiseList);
     if (update) {
       console.log('Update chain connection state');
       this.chainStateMapSubject.next(chainStateMap);
@@ -1120,7 +1139,6 @@ class ChainService {
       this.setAssetSettings(assetSettings, false);
     }
     this.eventService.emit('asset.ready', true);
-    console.log('Done init asset settings');
   }
   setAssetSettings(assetSettings) {
     let emitEvent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
@@ -1135,7 +1153,7 @@ class ChainService {
     }
     this.assetSettingSubject.next(assetSettings);
     updateAssets.forEach(slug => {
-      this.eventService.emit(assetSettings[slug].visible ? 'asset.enable' : 'asset.disable', slug);
+      this.eventService.emit('asset.updateState', slug);
     });
     this.store.set('AssetSetting', assetSettings);
   }
@@ -1184,5 +1202,11 @@ class ChainService {
   subscribeAssetSettings() {
     return this.assetSettingSubject;
   }
+  async getChainLogoMap() {
+    return Promise.resolve(_chainList.ChainLogoMap);
+  }
+  async getAssetLogoMap() {
+    return Promise.resolve(_chainList.AssetLogoMap);
+  }
 }
 exports.ChainService = ChainService;

package/cjs/services/event-service/index.js

@@ -42,7 +42,11 @@ class EventService extends _eventemitter.default {
     }, this.lazyTime);
   }
   emitLazy() {
-    this.lazyEmitter.emit('lazy', this.pendingEvents, this.pendingEvents.map(e => e.type));
+    try {
+      this.lazyEmitter.emit('lazy', this.pendingEvents, this.pendingEvents.map(e => e.type));
+    } catch (e) {
+      console.error('Get error in some listener of lazy event', e);
+    }
     this.pendingEvents = [];
     this.timeoutId = null;
   }

package/cjs/services/event-service/types.js

@@ -1 +1,11 @@
-"use strict";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.COMMON_RELOAD_EVENTS = void 0;
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const COMMON_RELOAD_EVENTS = ['account.updateCurrent', 'asset.updateState', 'account.add', 'chain.updateState', 'account.remove', 'chain.add'];
+exports.COMMON_RELOAD_EVENTS = COMMON_RELOAD_EVENTS;

package/cjs/services/history-service/index.js

@@ -5,9 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.HistoryService = void 0;
 var _constants = require("@subwallet/extension-base/constants");
-var _address = require("@subwallet/extension-base/utils/address");
+var _types = require("@subwallet/extension-base/services/base/types");
+var _promise = require("@subwallet/extension-base/utils/promise");
 var _uiKeyring = require("@subwallet/ui-keyring");
-var _accounts = require("@subwallet/ui-keyring/observable/accounts");
 var _rxjs = require("rxjs");
 var _subsquidMultiChainHistory = require("./subsquid-multi-chain-history");
 // Copyright 2019-2022 @subwallet/extension-base
@@ -15,28 +15,15 @@ var _subsquidMultiChainHistory = require("./subsquid-multi-chain-history");
 
 class HistoryService {
   historySubject = new _rxjs.BehaviorSubject([]);
-  constructor(dbService, chainService, eventService) {
+  constructor(dbService, chainService, eventService, keyringService) {
     this.dbService = dbService;
     this.chainService = chainService;
     this.eventService = eventService;
-    // Load history from database
-    this.dbService.getHistories().then(histories => {
-      this.historySubject.next(histories);
-    }).catch(console.error);
-
-    // Wait for keyring and chain ready and start
-    Promise.all([this.eventService.waitKeyringReady, this.eventService.waitChainReady]).then(() => {
-      this.getHistories().catch(console.log);
-      this.eventService.on('account.add', () => {
-        this.refreshHistoryInterval();
-      });
-      this.eventService.on('account.remove', address => {
-        this.removeHistoryByAddress(address).catch(console.error);
-      });
-    }).catch(console.error);
+    this.keyringService = keyringService;
+    this.init().catch(console.error);
   }
   fetchPromise = null;
-  nextFetch = undefined;
+  interval = undefined;
   async fetchAndLoadHistories(addresses) {
     if (!addresses || addresses.length === 0) {
       return [];
@@ -47,7 +34,7 @@ class HistoryService {
     const historyRecords = await (0, _subsquidMultiChainHistory.fetchMultiChainHistories)(addresses, chainMap);
 
     // Fill additional info
-    const accountMap = Object.entries(_accounts.accounts.subject.value).reduce((map, _ref) => {
+    const accountMap = Object.entries(this.keyringService.accounts).reduce((map, _ref) => {
       let [address, account] = _ref;
       map[address.toLowerCase()] = account.json.meta.name || address;
       return map;
@@ -57,44 +44,24 @@ class HistoryService {
       record.fromName = accountMap[(_record$from = record.from) === null || _record$from === void 0 ? void 0 : _record$from.toLowerCase()];
       record.toName = accountMap[(_record$to = record.to) === null || _record$to === void 0 ? void 0 : _record$to.toLowerCase()];
     });
-    this.dbService.upsertHistory(historyRecords).catch(console.error);
+    await this.addHistoryItems(historyRecords);
     return historyRecords;
   }
-  async fetchHistories(addresses) {
-    if (!this.fetchPromise) {
-      // Fetch another histories data data indexer and merge it with stored in database
-      this.fetchPromise = this.fetchAndLoadHistories(addresses);
-    }
-    return this.fetchPromise;
-  }
-  invalidCache() {
-    this.fetchPromise = null;
-  }
-  refreshHistoryInterval() {
-    clearTimeout(this.nextFetch);
-    this.invalidCache();
-    this.getHistories().catch(console.error);
-    this.nextFetch = setTimeout(() => {
-      this.refreshHistoryInterval();
-    }, _constants.CRON_REFRESH_HISTORY_INTERVAL);
-  }
   async getHistories() {
     const addressList = _uiKeyring.keyring.getAccounts().map(a => a.address);
-    const currentHistories = this.historySubject.value;
-    if (!this.fetchPromise || currentHistories.length === 0) {
-      const historyRecords = await this.fetchHistories(addressList);
-      this.historySubject.next(historyRecords);
+    if (!this.fetchPromise) {
+      this.fetchPromise = (async () => {
+        await this.fetchAndLoadHistories(addressList);
+        const histories = await this.dbService.getHistories();
+        this.historySubject.next(histories);
+      })();
     }
-    return this.historySubject.getValue();
+    return Promise.resolve(this.historySubject.getValue());
   }
   async getHistorySubject() {
     await this.getHistories();
     return this.historySubject;
   }
-  async insertHistories(historyItems) {
-    await this.dbService.upsertHistory(historyItems);
-    this.historySubject.next(await this.dbService.getHistories());
-  }
   async updateHistories(chain, extrinsicHash, updateData) {
     const existedRecords = await this.dbService.getHistories({
       chain,
@@ -108,14 +75,29 @@ class HistoryService {
     });
     await this.addHistoryItems(updatedRecords);
   }
+  async updateHistoryByExtrinsicHash(extrinsicHash, updateData) {
+    await this.dbService.updateHistoryByNewExtrinsicHash(extrinsicHash, updateData);
+    this.historySubject.next(await this.dbService.getHistories());
+  }
+
+  // Insert history without check override origin 'app'
+  async insertHistories(historyItems) {
+    await this.dbService.upsertHistory(historyItems);
+    this.historySubject.next(await this.dbService.getHistories());
+  }
+
+  // Insert history with check override origin 'app'
   async addHistoryItems(historyItems) {
     // Prevent override record with original is 'app'
     const appRecords = this.historySubject.value.filter(item => item.origin === 'app');
     const excludeKeys = appRecords.map(item => {
-      return `${item.chain}-${(0, _address.quickFormatAddressToCompare)(item.address) || ''}-${item.extrinsicHash}`;
+      return `${item.chain}-${item.extrinsicHash}`;
     });
     const updateRecords = historyItems.filter(item => {
-      const key = `${item.chain}-${(0, _address.quickFormatAddressToCompare)(item.address) || ''}-${item.extrinsicHash}`;
+      const key = `${item.chain}-${item.extrinsicHash}`;
+
+      // !excludeKeys.includes(key) && console.log('Cancel update', key);
+
       return item.origin === 'app' || !excludeKeys.includes(key);
     });
     await this.dbService.upsertHistory(updateRecords);
@@ -125,5 +107,74 @@ class HistoryService {
     await this.dbService.stores.transaction.removeAllByAddress(address);
     this.historySubject.next(await this.dbService.getHistories());
   }
+  status = _types.ServiceStatus.NOT_INITIALIZED;
+  async loadData() {
+    const histories = await this.dbService.getHistories();
+    this.historySubject.next(histories);
+  }
+  async persistData() {
+    await this.dbService.upsertHistory(this.historySubject.value);
+  }
+  async startCron() {
+    await this.getHistories();
+    this.interval = setInterval(() => {
+      this.getHistories().catch(console.error);
+    }, _constants.CRON_REFRESH_HISTORY_INTERVAL);
+  }
+  stopCron() {
+    clearTimeout(this.interval);
+    this.fetchPromise = null;
+    return Promise.resolve();
+  }
+  startPromiseHandler = (0, _promise.createPromiseHandler)();
+  async init() {
+    this.status = _types.ServiceStatus.INITIALIZING;
+    await this.loadData();
+    Promise.all([this.eventService.waitKeyringReady, this.eventService.waitChainReady]).then(() => {
+      this.getHistories().catch(console.log);
+      this.eventService.on('account.add', () => {
+        (async () => {
+          await this.stopCron();
+          await this.startCron();
+        })().catch(console.error);
+      });
+      this.eventService.on('account.remove', address => {
+        this.removeHistoryByAddress(address).catch(console.error);
+      });
+    }).catch(console.error);
+    this.status = _types.ServiceStatus.INITIALIZED;
+  }
+  async start() {
+    try {
+      console.debug('Start history service');
+      this.startPromiseHandler = (0, _promise.createPromiseHandler)();
+      this.status = _types.ServiceStatus.STARTING;
+      await this.startCron();
+      this.status = _types.ServiceStatus.STARTED;
+      this.startPromiseHandler.resolve();
+    } catch (e) {
+      this.startPromiseHandler.reject(e);
+    }
+  }
+  waitForStarted() {
+    return this.startPromiseHandler.promise;
+  }
+  stopPromiseHandler = (0, _promise.createPromiseHandler)();
+  async stop() {
+    console.debug('Stop history service');
+    try {
+      this.stopPromiseHandler = (0, _promise.createPromiseHandler)();
+      this.status = _types.ServiceStatus.STOPPING;
+      await this.persistData();
+      await this.stopCron();
+      this.stopPromiseHandler.resolve();
+      this.status = _types.ServiceStatus.STOPPED;
+    } catch (e) {
+      this.stopPromiseHandler.reject(e);
+    }
+  }
+  waitForStopped() {
+    return this.stopPromiseHandler.promise;
+  }
 }
 exports.HistoryService = HistoryService;

package/cjs/services/history-service/subsquid-multi-chain-history.js

@@ -67,12 +67,15 @@ function autoFormatAddress(address) {
     return '';
   }
 }
-function generateSignature(_ref) {
-  let {
+function generateSignature(input) {
+  if (!input) {
+    return '';
+  }
+  const {
     r,
     s,
     v
-  } = _ref;
+  } = input;
   const rHex = r.startsWith('0x') ? r.slice(2) : r;
   const sHex = s.startsWith('0x') ? s.slice(2) : s;
   const vHex = parseInt(v).toString(16);
@@ -118,7 +121,7 @@ function parseSubsquidTransactionData(address, type, historyItem, chainInfo, arg
         const transaction = data.call.data.args.transaction.value;
         to = autoFormatAddress(parsedArgs.to);
         from = autoFormatAddress(parsedArgs.from);
-        extrinsicHash = parsedArgs.transactionHash;
+        extrinsicHash = parsedArgs.transactionHash || extrinsic.hash;
         amount = transaction.value || '0';
         fee = (parseInt(transaction.gasPrice) * parseInt(transaction.gasLimit)).toString();
         signature = generateSignature(transaction.signature);
@@ -255,14 +258,14 @@ async function fetchMultiChainHistories(addresses, chainMap) {
       console.warn(`Not found chain info for chain id: ${chainId}`);
       return;
     }
-    try {
-      usedAddresses.forEach(address => {
+    usedAddresses.forEach(address => {
+      try {
         const transactionData = parseSubsquidTransactionData(address, name, historyItem, chainInfo, parseData(args), parseData(_data));
         histories.push(transactionData);
-      });
-    } catch (e) {
-      console.warn('Parse transaction data failed', e);
-    }
+      } catch (e) {
+        console.warn('Parse transaction data failed', address, e);
+      }
+    });
   });
   return histories;
 }

package/cjs/services/keyring-service/index.js

@@ -16,8 +16,9 @@ class KeyringService {
     address: '',
     currentGenesisHash: null
   });
-  accountsSubject = _uiKeyring.keyring.accounts.subject;
-  beforeAccount = _uiKeyring.keyring.accounts.subject.value;
+  addressesSubject = _uiKeyring.keyring.addresses.subject;
+  accountSubject = _uiKeyring.keyring.accounts.subject;
+  beforeAccount = this.accountSubject.value;
   keyringStateSubject = new _rxjs.BehaviorSubject({
     isReady: false,
     hasMasterPassword: false,
@@ -26,23 +27,17 @@ class KeyringService {
   constructor(eventService) {
     this.eventService = eventService;
     this.currentAccountStore.get('CurrentAccountInfo', rs => {
-      this.currentAccountSubject.next(rs);
+      rs && this.currentAccountSubject.next(rs);
     });
     this.subscribeAccounts().catch(console.error);
   }
   async subscribeAccounts() {
     // Wait until account ready
-    await new Promise(resolve => {
-      const onReady = () => {
-        this.eventService.off('account.ready', onReady);
-        resolve(true);
-      };
-      this.eventService.on('account.ready', onReady);
-    });
+    await this.eventService.waitAccountReady;
     this.beforeAccount = {
-      ...this.accountsSubject.value
+      ...this.accountSubject.value
     };
-    this.accountsSubject.subscribe(subjectInfo => {
+    this.accountSubject.subscribe(subjectInfo => {
       // Check if accounts changed
       const beforeAddresses = Object.keys(this.beforeAccount);
       const afterAddresses = Object.keys(subjectInfo);
@@ -87,7 +82,10 @@ class KeyringService {
     });
   }
   get accounts() {
-    return this.accountsSubject.value;
+    return this.accountSubject.value;
+  }
+  get addresses() {
+    return this.addressesSubject.value;
   }
   get currentAccount() {
     return this.currentAccountSubject.value;

package/cjs/services/migration-service/scripts/MigrateImportedToken.js

@@ -33,7 +33,8 @@ class MigrateImportedToken extends _Base.default {
                   originChain: item.chain,
                   priceId: null,
                   slug: '',
-                  symbol: item.symbol || ''
+                  symbol: item.symbol || '',
+                  icon: ''
                 });
               } catch (e) {
                 console.log(e);

package/cjs/services/price-service/coingecko.js

@@ -24,7 +24,6 @@ const getTokenPrice = async function (priceIds) {
       }
     }
     if (useBackupApi || ((_res = res) === null || _res === void 0 ? void 0 : _res.status) !== 200) {
-      console.log('Use backup api for price');
       useBackupApi = true;
       res = await _axios.default.get(`https://chain-data.subwallet.app/api/price/get?ids=${idStr}`);
     }