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

package/services/history-service/index.js

@@ -1,14 +1,17 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-import { CRON_REFRESH_HISTORY_INTERVAL } from '@subwallet/extension-base/constants';
+import { ExtrinsicStatus } from '@subwallet/extension-base/background/KoniTypes';
+import { CRON_RECOVER_HISTORY_INTERVAL, CRON_REFRESH_HISTORY_INTERVAL } from '@subwallet/extension-base/constants';
 import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
+import { historyRecover, HistoryRecoverStatus } from '@subwallet/extension-base/services/history-service/helpers/recoverHistoryStatus';
 import { createPromiseHandler } from '@subwallet/extension-base/utils/promise';
 import { keyring } from '@subwallet/ui-keyring';
 import { BehaviorSubject } from 'rxjs';
 import { fetchMultiChainHistories } from "./subsquid-multi-chain-history.js";
 export class HistoryService {
   historySubject = new BehaviorSubject([]);
+  #needRecoveryHistories = {};
   constructor(dbService, chainService, eventService, keyringService) {
     this.dbService = dbService;
     this.chainService = chainService;
@@ -18,6 +21,7 @@ export class HistoryService {
   }
   fetchPromise = null;
   interval = undefined;
+  recoverInterval = undefined;
   async fetchAndLoadHistories(addresses) {
     if (!addresses || addresses.length === 0) {
       return [];
@@ -69,7 +73,7 @@ export class HistoryService {
     await this.addHistoryItems(updatedRecords);
   }
   async updateHistoryByExtrinsicHash(extrinsicHash, updateData) {
-    await this.dbService.updateHistoryByNewExtrinsicHash(extrinsicHash, updateData);
+    await this.dbService.updateHistoryByExtrinsicHash(extrinsicHash, updateData);
     this.historySubject.next(await this.dbService.getHistories());
   }
 
@@ -88,9 +92,6 @@ export 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);
@@ -119,12 +120,60 @@ export class HistoryService {
     this.fetchPromise = null;
     return Promise.resolve();
   }
+  async startRecoverHistories() {
+    await this.recoverHistories();
+    this.recoverInterval = setInterval(() => {
+      this.recoverHistories().catch(console.error);
+    }, CRON_RECOVER_HISTORY_INTERVAL);
+  }
+  stopRecoverHistories() {
+    clearInterval(this.recoverInterval);
+    return Promise.resolve();
+  }
+  async recoverHistories() {
+    const list = [];
+    for (const processingHistory of Object.values(this.#needRecoveryHistories)) {
+      const chainState = this.chainService.getChainStateByKey(processingHistory.chain);
+      if (chainState.active) {
+        list.push(processingHistory);
+      }
+      if (list.length >= 10) {
+        break;
+      }
+    }
+    const promises = list.map(history => historyRecover(history, this.chainService));
+    const results = await Promise.all(promises);
+    results.forEach((recoverResult, index) => {
+      const currentExtrinsicHash = list[index].extrinsicHash;
+      const updateData = {
+        ...recoverResult,
+        status: ExtrinsicStatus.UNKNOWN
+      };
+      switch (recoverResult.status) {
+        case HistoryRecoverStatus.API_INACTIVE:
+          break;
+        case HistoryRecoverStatus.FAILED:
+        case HistoryRecoverStatus.SUCCESS:
+          updateData.status = recoverResult.status === HistoryRecoverStatus.SUCCESS ? ExtrinsicStatus.SUCCESS : ExtrinsicStatus.FAIL;
+          this.updateHistoryByExtrinsicHash(currentExtrinsicHash, updateData).catch(console.error);
+          delete this.#needRecoveryHistories[currentExtrinsicHash];
+          break;
+        default:
+          this.updateHistoryByExtrinsicHash(currentExtrinsicHash, updateData).catch(console.error);
+          delete this.#needRecoveryHistories[currentExtrinsicHash];
+      }
+    });
+    if (!Object.keys(this.#needRecoveryHistories).length) {
+      await this.stopRecoverHistories();
+    }
+  }
   startPromiseHandler = createPromiseHandler();
   async init() {
     this.status = ServiceStatus.INITIALIZING;
     await this.loadData();
     Promise.all([this.eventService.waitKeyringReady, this.eventService.waitChainReady]).then(() => {
       this.getHistories().catch(console.log);
+      this.recoverProcessingHistory().catch(console.error);
       this.eventService.on('account.add', () => {
         (async () => {
           await this.stopCron();
@@ -137,9 +186,22 @@ export class HistoryService {
     }).catch(console.error);
     this.status = ServiceStatus.INITIALIZED;
   }
+  async recoverProcessingHistory() {
+    const histories = await this.dbService.getHistories();
+    this.#needRecoveryHistories = {};
+    histories.filter(history => {
+      return [ExtrinsicStatus.PROCESSING, ExtrinsicStatus.SUBMITTING].includes(history.status);
+    }).forEach(history => {
+      this.#needRecoveryHistories[history.extrinsicHash] = history;
+    });
+    const recoverNumber = Object.keys(this.#needRecoveryHistories).length;
+    if (recoverNumber > 0) {
+      console.log(`Recover ${recoverNumber} processing history`);
+    }
+    this.startRecoverHistories().catch(console.error);
+  }
   async start() {
     try {
-      console.debug('Start history service');
       this.startPromiseHandler = createPromiseHandler();
       this.status = ServiceStatus.STARTING;
       await this.startCron();
@@ -154,12 +216,12 @@ export class HistoryService {
   }
   stopPromiseHandler = createPromiseHandler();
   async stop() {
-    console.debug('Stop history service');
     try {
       this.stopPromiseHandler = createPromiseHandler();
       this.status = ServiceStatus.STOPPING;
       await this.persistData();
       await this.stopCron();
+      await this.stopRecoverHistories();
       this.stopPromiseHandler.resolve();
       this.status = ServiceStatus.STOPPED;
     } catch (e) {

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

@@ -110,7 +110,7 @@ export function parseSubsquidTransactionData(address, type, historyItem, chainIn
         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();
@@ -244,7 +244,8 @@ export async function fetchMultiChainHistories(addresses, chainMap, maxPage = 25
     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 => {

package/services/history-service/testChainMap.d.ts

@@ -0,0 +1,3 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+export declare const TEST_CHAIN_LIST: _ChainInfo[];
+export declare const TEST_CHAIN_MAP: Record<string, _ChainInfo>;