@subwallet/extension-base 1.0.1 → 1.0.2-1b

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

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.HistoryService = void 0;
 var _constants = require("@subwallet/extension-base/constants");
+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");
@@ -13,20 +14,25 @@ var _subsquidMultiChainHistory = require("./subsquid-multi-chain-history");
 
 class HistoryService {
   historySubject = new _rxjs.BehaviorSubject([]);
-  constructor(dbService, chainService) {
+  constructor(dbService, chainService, eventService) {
     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);
 
-    // Add some delay to avoid fetching many times when start extension background
-    setTimeout(() => {
-      // Create history interval and refresh it if changes accounts list
-      _accounts.accounts.subject.subscribe(this.refreshHistoryInterval.bind(this));
-    }, 3333);
+    // 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);
   }
   fetchPromise = null;
   nextFetch = undefined;
@@ -50,8 +56,8 @@ 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()];
     });
-    await this.dbService.upsertHistory(historyRecords);
-    return await this.dbService.getHistories();
+    await this.addHistoryItems(historyRecords);
+    return historyRecords;
   }
   async fetchHistories(addresses) {
     if (!this.fetchPromise) {
@@ -67,13 +73,16 @@ class HistoryService {
     clearTimeout(this.nextFetch);
     this.invalidCache();
     this.getHistories().catch(console.error);
-    this.nextFetch = setTimeout(this.refreshHistoryInterval.bind(this), _constants.CRON_REFRESH_HISTORY_INTERVAL);
+    this.nextFetch = setTimeout(() => {
+      this.refreshHistoryInterval();
+    }, _constants.CRON_REFRESH_HISTORY_INTERVAL);
   }
   async getHistories() {
-    const addressList = Object.keys(_accounts.accounts.subject.value);
-    if (!this.fetchPromise) {
-      const historyRecords = await this.fetchHistories(addressList);
-      this.historySubject.next(historyRecords);
+    const addressList = _uiKeyring.keyring.getAccounts().map(a => a.address);
+    const currentHistories = this.historySubject.value;
+    if (!this.fetchPromise || currentHistories.length === 0) {
+      await this.fetchHistories(addressList);
+      this.historySubject.next(await this.dbService.getHistories());
     }
     return this.historySubject.getValue();
   }
@@ -81,11 +90,7 @@ class HistoryService {
     await this.getHistories();
     return this.historySubject;
   }
-  async insertHistory(historyItem) {
-    await this.dbService.upsertHistory([historyItem]);
-    this.historySubject.next(await this.dbService.getHistories());
-  }
-  async updateHistory(chain, extrinsicHash, historyItem) {
+  async updateHistories(chain, extrinsicHash, updateData) {
     const existedRecords = await this.dbService.getHistories({
       chain,
       extrinsicHash
@@ -93,15 +98,35 @@ class HistoryService {
     const updatedRecords = existedRecords.map(r => {
       return {
         ...r,
-        ...historyItem
+        ...updateData
       };
     });
     await this.addHistoryItems(updatedRecords);
   }
-  async addHistoryItems(historyItems) {
+
+  // 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}-${item.extrinsicHash}`;
+    });
+    const updateRecords = historyItems.filter(item => {
+      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);
+    this.historySubject.next(await this.dbService.getHistories());
+  }
   async removeHistoryByAddress(address) {
     await this.dbService.stores.transaction.removeAllByAddress(address);
     this.historySubject.next(await this.dbService.getHistories());

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);
@@ -119,10 +122,15 @@ function parseSubsquidTransactionData(address, type, historyItem, chainInfo, arg
         to = autoFormatAddress(parsedArgs.to);
         from = autoFormatAddress(parsedArgs.from);
         extrinsicHash = parsedArgs.transactionHash;
-        amount = transaction.value;
+        amount = transaction.value || '0';
         fee = (parseInt(transaction.gasPrice) * parseInt(transaction.gasLimit)).toString();
         signature = generateSignature(transaction.signature);
         success = extrinsic.success;
+
+        // Special fix for moonbeam
+        if ((historyItem.chainId === 'moonbeam' || historyItem.chainId === 'moonriver') && typeof amount === 'object') {
+          amount = amount[0];
+        }
         break;
       }
 
@@ -167,7 +175,7 @@ function parseSubsquidTransactionData(address, type, historyItem, chainInfo, arg
   }
   return {
     address,
-    origin: MULTI_CHAIN_URL,
+    origin: 'subsquid',
     time: toTimestamp(historyItem.timestamp),
     chainType,
     from,
@@ -250,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

@@ -0,0 +1,101 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.KeyringService = void 0;
+var _stores = require("@subwallet/extension-base/stores");
+var _uiKeyring = require("@subwallet/ui-keyring");
+var _rxjs = require("rxjs");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+class KeyringService {
+  currentAccountStore = new _stores.CurrentAccountStore();
+  currentAccountSubject = new _rxjs.BehaviorSubject({
+    address: '',
+    currentGenesisHash: null
+  });
+  accountsSubject = _uiKeyring.keyring.accounts.subject;
+  beforeAccount = _uiKeyring.keyring.accounts.subject.value;
+  keyringStateSubject = new _rxjs.BehaviorSubject({
+    isReady: false,
+    hasMasterPassword: false,
+    isLocked: false
+  });
+  constructor(eventService) {
+    this.eventService = eventService;
+    this.currentAccountStore.get('CurrentAccountInfo', 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);
+    });
+    this.beforeAccount = {
+      ...this.accountsSubject.value
+    };
+    this.accountsSubject.subscribe(subjectInfo => {
+      // Check if accounts changed
+      const beforeAddresses = Object.keys(this.beforeAccount);
+      const afterAddresses = Object.keys(subjectInfo);
+      if (beforeAddresses.length > afterAddresses.length) {
+        const removedAddresses = beforeAddresses.filter(address => !afterAddresses.includes(address));
+
+        // Remove account
+        removedAddresses.forEach(address => {
+          console.log('account.remove', address);
+          this.eventService.emit('account.remove', address);
+        });
+      } else if (beforeAddresses.length < afterAddresses.length) {
+        const addedAddresses = afterAddresses.filter(address => !beforeAddresses.includes(address));
+
+        // Add account
+        addedAddresses.forEach(address => {
+          console.log('account.add', address);
+          this.eventService.emit('account.add', address);
+        });
+      } else {
+        // Handle case update later
+      }
+      this.beforeAccount = {
+        ...subjectInfo
+      };
+    });
+  }
+  get keyringState() {
+    return this.keyringStateSubject.value;
+  }
+  updateKeyringState() {
+    var _keyring$keyring, _keyring$keyring2;
+    let isReady = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+    if (!this.keyringState.isReady && isReady) {
+      this.eventService.emit('keyring.ready', true);
+      this.eventService.emit('account.ready', true);
+    }
+    this.keyringStateSubject.next({
+      hasMasterPassword: !!((_keyring$keyring = _uiKeyring.keyring.keyring) !== null && _keyring$keyring !== void 0 && _keyring$keyring.hasMasterPassword),
+      isLocked: !!((_keyring$keyring2 = _uiKeyring.keyring.keyring) !== null && _keyring$keyring2 !== void 0 && _keyring$keyring2.isLocked),
+      isReady: isReady
+    });
+  }
+  get accounts() {
+    return this.accountsSubject.value;
+  }
+  get currentAccount() {
+    return this.currentAccountSubject.value;
+  }
+  setCurrentAccount(currentAccountData) {
+    this.currentAccountSubject.next(currentAccountData);
+    this.eventService.emit('account.updateCurrent', currentAccountData);
+    this.currentAccountStore.set('CurrentAccountInfo', currentAccountData);
+  }
+}
+exports.KeyringService = KeyringService;

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

@@ -1,12 +1,13 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
 var _util = require("@polkadot/util");
-var _scripts = _interopRequireDefault(require("./scripts"));
+var _scripts = _interopRequireWildcard(require("./scripts"));
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -21,23 +22,25 @@ class MigrationService {
     try {
       for (let i = 0; i < keys.length; i++) {
         const JobClass = _scripts.default[keys[i]];
+        const key = keys[i];
+        const name = JobClass.name;
         const check = await this.state.dbService.stores.migration.table.where({
-          name: JobClass.name,
-          key: keys[i]
+          name,
+          key
         }).first();
-        if (!check) {
-          const job = new JobClass(this.state);
+        if (!check || key.startsWith(_scripts.EVERYTIME)) {
           this.logger.log('Running script: ', JobClass.name);
+          const job = new JobClass(this.state);
           await job.run();
           await this.state.dbService.stores.migration.table.put({
-            key: keys[i],
-            name: JobClass.name,
-            timestamp: +new Date()
+            key,
+            name,
+            timestamp: new Date().getTime()
           });
         }
       }
     } catch (error) {
-      this.logger.warn('Migration error: ', error);
+      this.logger.error('Migration error: ', error);
     }
     this.logger.log('Migration done.');
   }

package/cjs/{koni/migration/scripts/RemoveWrongCrowdloan.js → services/migration-service/scripts/AutoEnableChainsTokens.js}

@@ -5,15 +5,20 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _Base = _interopRequireDefault(require("@subwallet/extension-base/koni/migration/Base"));
-var _databases = _interopRequireDefault(require("@subwallet/extension-base/services/storage-service/databases"));
+var _Base = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/Base"));
+var _uiKeyring = require("@subwallet/ui-keyring");
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-class RemoveWrongCrowdloan extends _Base.default {
+class AutoEnableChainsTokens extends _Base.default {
   async run() {
-    const db = new _databases.default();
-    await db.crowdloans.clear();
+    const accounts = _uiKeyring.keyring.getAccounts();
+    await this.state.autoEnableChains(accounts.map(_ref => {
+      let {
+        address
+      } = _ref;
+      return address;
+    }));
   }
 }
-exports.default = RemoveWrongCrowdloan;
+exports.default = AutoEnableChainsTokens;

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

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
+var _types = require("@subwallet/chain-list/types");
 var _Base = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/Base"));
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
@@ -12,28 +13,47 @@ var _Base = _interopRequireDefault(require("@subwallet/extension-base/services/m
 class MigrateNetworkSettings extends _Base.default {
   async run() {
     const state = this.state;
-    return new Promise((resolve, reject) => {
-      chrome.storage.local.get('NetworkMap', function (items) {
-        if (items && items.NetworkMap) {
-          const networkMap = items.NetworkMap;
-          const enableList = [];
-          const stateMap = state.getChainStateMap();
-          Object.entries(networkMap).forEach(_ref => {
-            let [slug, chain] = _ref;
-            if (chain.active) {
-              const currentState = stateMap[slug];
+    const items = await new Promise(resolve => {
+      chrome.storage.local.get('NetworkMap', items => {
+        resolve(items);
+      });
+    });
+    const oldNetworkMap = items.NetworkMap;
+    const enableList = [];
+    const stateMap = state.getChainStateMap();
+    if (!oldNetworkMap) {
+      return;
+    }
+    Object.entries(oldNetworkMap).forEach(_ref => {
+      let [slug, chain] = _ref;
+      if (chain.active) {
+        const currentState = stateMap[slug];
+
+        // Ensure chain in the list and is not active
+        currentState && enableList.push(slug);
+      }
+    });
+    if (enableList.length > 0) {
+      state.chainService.enableChains(enableList);
 
-              // Ensure chain in the list and is not active
-              currentState && !currentState.active && enableList.push(slug);
-            }
-          });
-          if (enableList.length > 0) {
-            state.chainService.enableChains(enableList);
-          }
+      // Enable native token of these chains
+      const currentAssetSettings = await state.chainService.getAssetSettings();
+      const assetInfoMap = state.chainService.getAssetRegistry();
+      Object.entries(assetInfoMap).forEach(_ref2 => {
+        let [slug, assetInfo] = _ref2;
+        const assetSetting = currentAssetSettings[slug] || {};
+
+        // Enable native token of these chains
+        if (assetInfo.name && assetInfo.assetType === _types._AssetType.NATIVE && enableList.includes(assetInfo.originChain) && !assetSetting.visible) {
+          currentAssetSettings[slug] = {
+            visible: true
+          };
         }
-        resolve();
       });
-    });
+      state.chainService.setAssetSettings({
+        ...currentAssetSettings
+      });
+    }
   }
 }
 exports.default = MigrateNetworkSettings;

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

@@ -0,0 +1,31 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Base = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/Base"));
+var _uiSettings = _interopRequireDefault(require("@polkadot/ui-settings"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class MigrateSettings extends _Base.default {
+  async run() {
+    try {
+      return new Promise(resolve => {
+        this.state.settingService.getSettings(currentSettings => {
+          const isAccessCamera = _uiSettings.default.camera === 'on';
+          this.state.settingService.setSettings({
+            ...currentSettings,
+            camera: isAccessCamera
+          });
+          resolve();
+        });
+      });
+    } catch (e) {
+      console.error(e);
+    }
+  }
+}
+exports.default = MigrateSettings;

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

@@ -0,0 +1,72 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _Base = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/Base"));
+var _dexie = _interopRequireDefault(require("dexie"));
+var _utilCrypto = require("@polkadot/util-crypto");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class MigrateTransactionHistory extends _Base.default {
+  async run() {
+    const state = this.state;
+    const chainInfoMap = state.getChainInfoMap();
+    const assetList = Object.values(state.getAssetRegistry());
+    try {
+      const db = new _dexie.default('SubWalletDB');
+      const dexieDB = await db.open();
+      const transactionTable = dexieDB.table('transactions');
+      const oldTransactionData = await transactionTable.toArray();
+      const newTransactionItems = [];
+      oldTransactionData.forEach(item => {
+        const chainInfo = chainInfoMap[item.networkKey];
+        if (!chainInfo) {
+          return;
+        }
+        const direction = item.action === 'send' ? _KoniTypes.TransactionDirection.SEND : _KoniTypes.TransactionDirection.RECEIVED;
+        const extrinsicType = item.changeSymbol === item.feeSymbol ? _KoniTypes.ExtrinsicType.TRANSFER_BALANCE : _KoniTypes.ExtrinsicType.TRANSFER_TOKEN;
+        const nativeAsset = (0, _utils._getChainNativeTokenBasicInfo)(chainInfo);
+        const transferAsset = assetList.find(a => a.originChain === item.networkKey && a.symbol === item.changeSymbol) || nativeAsset;
+        const newItem = {
+          chain: item.networkKey,
+          origin: 'migration',
+          type: extrinsicType,
+          address: item.address,
+          extrinsicHash: item.extrinsicHash,
+          time: item.time,
+          status: item.isSuccess ? _KoniTypes.ExtrinsicStatus.SUCCESS : _KoniTypes.ExtrinsicStatus.FAIL,
+          from: direction === _KoniTypes.TransactionDirection.SEND ? item.address : '',
+          to: direction === _KoniTypes.TransactionDirection.RECEIVED ? item.address : '',
+          amount: {
+            value: item.change,
+            decimals: transferAsset.decimals || 18,
+            symbol: transferAsset.symbol
+          },
+          fee: {
+            value: item.fee,
+            decimals: nativeAsset.decimals,
+            symbol: nativeAsset.symbol
+          },
+          direction: direction,
+          chainType: (0, _utilCrypto.isEthereumAddress)(item.address) ? _KoniTypes.ChainType.EVM : _KoniTypes.ChainType.SUBSTRATE,
+          chainName: chainInfo.name,
+          blockNumber: 0,
+          blockHash: '',
+          data: '',
+          signature: ''
+        };
+        newTransactionItems.push(newItem);
+      });
+      await state.historyService.addHistoryItems(newTransactionItems);
+    } catch (e) {
+      this.logger.error(e);
+    }
+  }
+}
+exports.default = MigrateTransactionHistory;

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

@@ -4,14 +4,23 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.default = exports.EVERYTIME = void 0;
+var _AutoEnableChainsTokens = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/scripts/AutoEnableChainsTokens"));
 var _MigrateImportedToken = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/scripts/MigrateImportedToken"));
 var _MigrateNetworkSettings = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/scripts/MigrateNetworkSettings"));
+var _MigrateSettings = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/scripts/MigrateSettings"));
+var _MigrateTransactionHistory = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/scripts/MigrateTransactionHistory"));
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
+
+const EVERYTIME = '__everytime__';
+exports.EVERYTIME = EVERYTIME;
 var _default = {
-  '1.0.1-1': _MigrateNetworkSettings.default,
-  '1.0.1-2': _MigrateImportedToken.default
-  // '1.0.1-0': ClearOldStorage
+  '1.0.1-11': _MigrateNetworkSettings.default,
+  '1.0.1-20': _MigrateImportedToken.default,
+  '1.0.1-30': _MigrateTransactionHistory.default,
+  '1.0.1-40': _AutoEnableChainsTokens.default,
+  '1.0.1-50': _MigrateSettings.default
+  // [`${EVERYTIME}-1`]: AutoEnableChainsTokens
 };
 exports.default = _default;

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

@@ -9,16 +9,28 @@ var _axios = _interopRequireDefault(require("axios"));
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+let useBackupApi = false;
 const getTokenPrice = async function (priceIds) {
   let currency = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'usd';
   try {
+    var _res;
     const idStr = Array.from(priceIds).join(',');
-    // const res = await axios.get(`https://api.coingecko.com/api/v3/coins/markets?vs_currency=${currency}&per_page=250&ids=${idStr}`);
-    const res = await _axios.default.get(`https://chain-data.subwallet.app/api/price/get?ids=${idStr}`);
+    let res;
+    if (!useBackupApi) {
+      try {
+        res = await _axios.default.get(`https://api.coingecko.com/api/v3/coins/markets?vs_currency=${currency}&per_page=250&ids=${idStr}`);
+      } catch (err) {
+        useBackupApi = true;
+      }
+    }
+    if (useBackupApi || ((_res = res) === null || _res === void 0 ? void 0 : _res.status) !== 200) {
+      useBackupApi = true;
+      res = await _axios.default.get(`https://chain-data.subwallet.app/api/price/get?ids=${idStr}`);
+    }
     if (res.status !== 200) {
       console.warn('Failed to get token price');
     }
-    const responseData = res.data;
+    const responseData = res.data || [];
     const priceMap = {};
     const price24hMap = {};
     responseData.forEach(val => {

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

@@ -19,27 +19,27 @@ const DEFAULT_PRICE_SUBJECT = {
 class PriceService {
   priceSubject = new _rxjs.BehaviorSubject(DEFAULT_PRICE_SUBJECT);
   priceIds = new Set();
-  constructor(serviceInfoSubject, dbService, chainService) {
+  constructor(dbService, eventService, chainService) {
     this.dbService = dbService;
+    this.eventService = eventService;
     this.chainService = chainService;
 
     // Fetch data from storage
     this.getPrice().catch(console.error);
+    const eventHandler = () => {
+      const newPriceIds = this.getPriceIds();
 
-    // Add some delay to avoid fetching many times when start extension background
-    // Subscribe service info to update price list
-    setTimeout(() => {
+      // Compare two set newPriceIds and this.priceIds
+      if (newPriceIds.size !== this.priceIds.size || !Array.from(newPriceIds).every(v => this.priceIds.has(v))) {
+        this.priceIds = newPriceIds;
+        this.refreshPriceData(this.priceIds);
+      }
+    };
+    this.eventService.waitAssetReady.then(() => {
       this.refreshPriceData();
-      serviceInfoSubject.subscribe(serviceInfo => {
-        const newPriceIds = this.getPriceIds();
-
-        // Compare two set newPriceIds and this.priceIds
-        if (newPriceIds.size !== this.priceIds.size || !Array.from(newPriceIds).every(v => this.priceIds.has(v))) {
-          this.priceIds = newPriceIds;
-          this.refreshPriceData(this.priceIds);
-        }
-      });
-    }, 3000);
+      this.eventService.on('asset.updateState', eventHandler);
+      this.eventService.on('asset.updateState', eventHandler);
+    }).catch(console.error);
   }
   async getPrice() {
     const isReady = this.priceSubject.value.ready;
@@ -68,10 +68,7 @@ class PriceService {
         ready: true
       });
       this.dbService.updatePriceStore(rs).catch(console.error);
-      console.log('Get Token Price From CoinGecko');
-    }).catch(e => {
-      // Pass
-    });
+    }).catch(console.error);
     this.refreshTimeout = setTimeout(this.refreshPriceData.bind(this), _constants.CRON_REFRESH_PRICE_INTERVAL);
   }
 }