@subwallet/extension-base 1.0.4-0 → 1.0.5-1

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

@@ -4,8 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.HistoryService = void 0;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
 var _constants = require("@subwallet/extension-base/constants");
 var _types = require("@subwallet/extension-base/services/base/types");
+var _recoverHistoryStatus = require("@subwallet/extension-base/services/history-service/helpers/recoverHistoryStatus");
 var _promise = require("@subwallet/extension-base/utils/promise");
 var _uiKeyring = require("@subwallet/ui-keyring");
 var _rxjs = require("rxjs");
@@ -15,6 +17,7 @@ var _subsquidMultiChainHistory = require("./subsquid-multi-chain-history");
 
 class HistoryService {
   historySubject = new _rxjs.BehaviorSubject([]);
+  #processingHistories = {};
   constructor(dbService, chainService, eventService, keyringService) {
     this.dbService = dbService;
     this.chainService = chainService;
@@ -24,6 +27,7 @@ class HistoryService {
   }
   fetchPromise = null;
   interval = undefined;
+  recoverInterval = undefined;
   async fetchAndLoadHistories(addresses) {
     if (!addresses || addresses.length === 0) {
       return [];
@@ -95,9 +99,6 @@ class HistoryService {
     });
     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);
@@ -126,12 +127,56 @@ class HistoryService {
     this.fetchPromise = null;
     return Promise.resolve();
   }
+  async startRecoverHistories() {
+    await this.recoverHistories();
+    this.recoverInterval = setInterval(() => {
+      this.recoverHistories().catch(console.error);
+    }, _constants.CRON_RECOVER_HISTORY_INTERVAL);
+  }
+  stopRecoverHistories() {
+    clearInterval(this.recoverInterval);
+    return Promise.resolve();
+  }
+  async recoverHistories() {
+    const list = [];
+    for (const processingHistory of Object.values(this.#processingHistories)) {
+      const chainState = this.chainService.getChainStateByKey(processingHistory.chain);
+      if (chainState.active) {
+        list.push(processingHistory);
+      }
+      if (list.length >= 10) {
+        break;
+      }
+    }
+    const promises = list.map(history => (0, _recoverHistoryStatus.historyRecover)(history, this.chainService));
+    const result = await Promise.all(promises);
+    result.forEach((status, index) => {
+      const extrinsicHash = list[index].extrinsicHash;
+      switch (status) {
+        case _recoverHistoryStatus.HistoryRecoverStatus.API_INACTIVE:
+          break;
+        case _recoverHistoryStatus.HistoryRecoverStatus.FAILED:
+        case _recoverHistoryStatus.HistoryRecoverStatus.SUCCESS:
+          this.updateHistoryByExtrinsicHash(extrinsicHash, {
+            status: status === _recoverHistoryStatus.HistoryRecoverStatus.SUCCESS ? _KoniTypes.ExtrinsicStatus.SUCCESS : _KoniTypes.ExtrinsicStatus.FAIL
+          }).catch(console.error);
+          delete this.#processingHistories[extrinsicHash];
+          break;
+        default:
+          delete this.#processingHistories[extrinsicHash];
+      }
+    });
+    if (!Object.keys(this.#processingHistories).length) {
+      await this.stopRecoverHistories();
+    }
+  }
   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.getProcessingHistory().catch(console.log);
       this.eventService.on('account.add', () => {
         (async () => {
           await this.stopCron();
@@ -144,12 +189,22 @@ class HistoryService {
     }).catch(console.error);
     this.status = _types.ServiceStatus.INITIALIZED;
   }
+  async getProcessingHistory() {
+    const histories = await this.dbService.getHistories();
+    this.#processingHistories = {};
+    histories.filter(history => {
+      return history.status === 'processing';
+    }).forEach(history => {
+      this.#processingHistories[history.extrinsicHash] = history;
+    });
+    this.startRecoverHistories().catch(console.error);
+  }
   async start() {
     try {
-      console.debug('Start history service');
       this.startPromiseHandler = (0, _promise.createPromiseHandler)();
       this.status = _types.ServiceStatus.STARTING;
       await this.startCron();
+      await this.startRecoverHistories();
       this.status = _types.ServiceStatus.STARTED;
       this.startPromiseHandler.resolve();
     } catch (e) {
@@ -161,12 +216,12 @@ class HistoryService {
   }
   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();
+      await this.stopRecoverHistories();
       this.stopPromiseHandler.resolve();
       this.status = _types.ServiceStatus.STOPPED;
     } catch (e) {

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

@@ -120,7 +120,7 @@ function parseSubsquidTransactionData(address, type, historyItem, chainInfo, arg
         const parsedArgs = args;
         const transaction = data.call.data.args.transaction.value;
         to = autoFormatAddress(parsedArgs.to);
-        from = autoFormatAddress(parsedArgs.from);
+        from = autoFormatAddress(parsedArgs.from || address);
         extrinsicHash = parsedArgs.transactionHash || extrinsic.hash;
         amount = transaction.value || '0';
         fee = (parseInt(transaction.gasPrice) * parseInt(transaction.gasLimit)).toString();
@@ -255,7 +255,8 @@ async function fetchMultiChainHistories(addresses, chainMap) {
     const usedAddresses = relatedAddresses.filter(a => lowerAddresses.includes(a.toLowerCase()));
     const chainInfo = chainMap[chainId];
     if (chainInfo === undefined) {
-      console.warn(`Not found chain info for chain id: ${chainId}`);
+      console.warn(`Not found chain info for chain id: ${chainId}`); // TODO: resolve conflicting chainId
+
       return;
     }
     usedAddresses.forEach(address => {