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

package/background/KoniTypes.d.ts

@@ -419,6 +419,8 @@ export interface TransactionHistoryItem<ET extends ExtrinsicType = ExtrinsicType
     fee?: AmountData;
     explorerUrl?: string;
     additionalInfo?: TransactionAdditionalInfo<ET>;
+    startBlock?: number;
+    nonce?: number;
 }
 export interface SWError extends Error {
     code?: number;

package/cjs/koni/background/handlers/Extension.js

@@ -1299,7 +1299,7 @@ class KoniExtension {
     const isPasswordValidated = this.validatedAccountsPassword(file, password);
     if (isPasswordValidated) {
       try {
-        this._saveCurrentAccountAddress(addressList[0], () => {
+        this._saveCurrentAccountAddress(_constants.ALL_ACCOUNT_KEY, () => {
           _uiKeyring.keyring.restoreAccounts(file, password);
           this._addAddressesToAuthList(addressList, isAllowed);
         });

package/cjs/packageInfo.js

@@ -13,6 +13,6 @@ const packageInfo = {
   name: '@subwallet/extension-base',
   path: typeof __dirname === 'string' ? __dirname : 'auto',
   type: 'cjs',
-  version: '1.0.5-1'
+  version: '1.0.5-2'
 };
 exports.packageInfo = packageInfo;

package/cjs/services/history-service/helpers/recoverHistoryStatus.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.historyRecover = exports.HistoryRecoverStatus = void 0;
+var _utils = require("@subwallet/extension-base/utils");
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 let HistoryRecoverStatus;
@@ -16,78 +17,194 @@ exports.HistoryRecoverStatus = HistoryRecoverStatus;
   HistoryRecoverStatus["FAIL_DETECT"] = "FAIL_DETECT";
   HistoryRecoverStatus["UNKNOWN"] = "UNKNOWN";
 })(HistoryRecoverStatus || (exports.HistoryRecoverStatus = HistoryRecoverStatus = {}));
+const BLOCK_LIMIT = 6;
 const substrateRecover = async (history, chainService) => {
   const {
+    address,
     blockHash,
     chain,
-    extrinsicHash
+    extrinsicHash,
+    from,
+    nonce,
+    startBlock
   } = history;
+  const result = {
+    status: HistoryRecoverStatus.UNKNOWN
+  };
   try {
     const substrateApi = chainService.getSubstrateApi(chain);
     if (substrateApi) {
       const _api = await substrateApi.isReady;
       const api = _api.api;
       if (!blockHash) {
-        console.log(`Fail to find extrinsic ${extrinsicHash} on ${chain}: No block hash`);
-        return HistoryRecoverStatus.LACK_INFO;
-      }
-      const block = await api.rpc.chain.getBlock(blockHash);
-      const allEvents = await api.query.system.events.at(blockHash);
-      const extrinsics = block.block.extrinsics;
-      let index;
-      extrinsics.forEach((extrinsic, _idx) => {
-        if (extrinsicHash === extrinsic.hash.toHex()) {
-          index = _idx;
+        if (!nonce || !startBlock) {
+          console.log(`Fail to find extrinsic for ${address} on ${chain}: With nonce ${nonce || 'undefined'} from block ${startBlock || 'undefined'}`);
+          return {
+            status: HistoryRecoverStatus.LACK_INFO
+          };
         }
-      });
-      if (index === undefined) {
-        console.log(`Fail to find extrinsic ${extrinsicHash} on ${chain}`);
-        return HistoryRecoverStatus.FAIL_DETECT;
-      }
-      const events = allEvents.filter(_ref => {
-        let {
-          phase
-        } = _ref;
-        return phase.isApplyExtrinsic && phase.asApplyExtrinsic.eq(index);
-      });
-      for (const {
-        event
-      } of events) {
-        if (api.events.system.ExtrinsicSuccess.is(event)) {
-          return HistoryRecoverStatus.SUCCESS;
-        } else if (api.events.system.ExtrinsicFailed.is(event)) {
-          return HistoryRecoverStatus.FAILED;
+        const currentBlock = (await api.query.system.number()).toPrimitive();
+        for (let i = 1, found = false; i < BLOCK_LIMIT && !found && startBlock + i <= currentBlock; i++) {
+          const blockHash = (await api.rpc.chain.getBlockHash(startBlock + i)).toHex();
+          const block = await api.rpc.chain.getBlock(blockHash);
+          const extrinsics = block.block.extrinsics;
+          let index;
+          for (const [idx, extrinsic] of Object.entries(extrinsics)) {
+            if (extrinsic.signer && (0, _utils.isSameAddress)(from, extrinsic.signer.toString()) && nonce === extrinsic.nonce.toNumber()) {
+              index = parseInt(idx);
+              found = true;
+              result.extrinsicHash = extrinsic.hash.toHex();
+              result.blockHash = block.block.hash.toHex();
+              result.blockNumber = block.block.header.number.toNumber();
+              break;
+            }
+          }
+          if (index !== undefined) {
+            const allEvents = await api.query.system.events.at(blockHash);
+            const events = allEvents.filter(_ref => {
+              let {
+                phase
+              } = _ref;
+              return phase.isApplyExtrinsic && phase.asApplyExtrinsic.eq(index);
+            });
+            for (const {
+              event
+            } of events) {
+              if (api.events.system.ExtrinsicSuccess.is(event)) {
+                return {
+                  ...result,
+                  status: HistoryRecoverStatus.SUCCESS
+                };
+              } else if (api.events.system.ExtrinsicFailed.is(event)) {
+                return {
+                  ...result,
+                  status: HistoryRecoverStatus.FAILED
+                };
+              }
+            }
+          }
+        }
+      } else {
+        const block = await api.rpc.chain.getBlock(blockHash);
+        const allEvents = await api.query.system.events.at(blockHash);
+        const extrinsics = block.block.extrinsics;
+        let index;
+        for (const [idx, extrinsic] of Object.entries(extrinsics)) {
+          if (extrinsicHash === extrinsic.hash.toHex()) {
+            index = parseInt(idx);
+            break;
+          }
+        }
+        if (index === undefined) {
+          console.log(`Fail to find extrinsic ${extrinsicHash} on ${chain}`);
+          return {
+            status: HistoryRecoverStatus.FAIL_DETECT
+          };
+        }
+        const events = allEvents.filter(_ref2 => {
+          let {
+            phase
+          } = _ref2;
+          return phase.isApplyExtrinsic && phase.asApplyExtrinsic.eq(index);
+        });
+        for (const {
+          event
+        } of events) {
+          if (api.events.system.ExtrinsicSuccess.is(event)) {
+            return {
+              ...result,
+              status: HistoryRecoverStatus.SUCCESS
+            };
+          } else if (api.events.system.ExtrinsicFailed.is(event)) {
+            return {
+              ...result,
+              status: HistoryRecoverStatus.FAILED
+            };
+          }
         }
       }
-      return HistoryRecoverStatus.FAIL_DETECT;
+      return {
+        status: HistoryRecoverStatus.FAIL_DETECT
+      };
     } else {
       console.error(`Fail to update history ${chain}-${extrinsicHash}: Api not active`);
-      return HistoryRecoverStatus.API_INACTIVE;
+      return {
+        status: HistoryRecoverStatus.API_INACTIVE
+      };
     }
   } catch (e) {
     console.error(`Fail to update history ${chain}-${extrinsicHash}:`, e.message);
-    return HistoryRecoverStatus.UNKNOWN;
+    return {
+      status: HistoryRecoverStatus.UNKNOWN
+    };
   }
 };
 const evmRecover = async (history, chainService) => {
   const {
+    address,
     chain,
-    extrinsicHash
+    extrinsicHash,
+    from,
+    nonce,
+    startBlock
   } = history;
+  const result = {
+    status: HistoryRecoverStatus.UNKNOWN
+  };
   try {
     const evmApi = chainService.getEvmApi(chain);
     if (evmApi) {
       const _api = await evmApi.isReady;
       const api = _api.api;
-      const block = await api.eth.getTransactionReceipt(extrinsicHash);
-      return block.status ? HistoryRecoverStatus.SUCCESS : HistoryRecoverStatus.FAILED;
+      if (extrinsicHash) {
+        const transactionReceipt = await api.eth.getTransactionReceipt(extrinsicHash);
+        return {
+          ...result,
+          status: transactionReceipt.status ? HistoryRecoverStatus.SUCCESS : HistoryRecoverStatus.FAILED
+        };
+      } else {
+        if (!nonce || !startBlock) {
+          console.log(`Fail to find extrinsic for ${address} on ${chain}: With nonce ${nonce || 'undefined'} from block ${startBlock || 'undefined'}`);
+          return {
+            ...result,
+            status: HistoryRecoverStatus.LACK_INFO
+          };
+        }
+        const currentBlock = await api.eth.getBlockNumber();
+        for (let i = 1, found = false; i < BLOCK_LIMIT && !found && startBlock + i <= currentBlock; i++) {
+          const block = await api.eth.getBlock(startBlock + i, true);
+          for (const transaction of block.transactions) {
+            if ((0, _utils.isSameAddress)(transaction.from, from) && nonce === transaction.nonce) {
+              result.extrinsicHash = transaction.hash;
+              result.blockHash = block.hash;
+              result.blockNumber = block.number;
+              found = true;
+              break;
+            }
+          }
+          if (result.extrinsicHash) {
+            const transactionReceipt = await api.eth.getTransactionReceipt(result.extrinsicHash);
+            return {
+              ...result,
+              status: transactionReceipt.status ? HistoryRecoverStatus.SUCCESS : HistoryRecoverStatus.FAILED
+            };
+          }
+        }
+      }
+      return {
+        status: HistoryRecoverStatus.FAIL_DETECT
+      };
     } else {
       console.error(`Fail to update history ${chain}-${extrinsicHash}: Api not active`);
-      return HistoryRecoverStatus.API_INACTIVE;
+      return {
+        status: HistoryRecoverStatus.API_INACTIVE
+      };
     }
   } catch (e) {
     console.error(`Fail to update history ${chain}-${extrinsicHash}:`, e.message);
-    return HistoryRecoverStatus.UNKNOWN;
+    return {
+      status: HistoryRecoverStatus.UNKNOWN
+    };
   }
 };
 
@@ -102,7 +219,9 @@ const historyRecover = async (history, chainService) => {
     const checkFunction = chainType === 'substrate' ? substrateRecover : evmRecover;
     return await checkFunction(history, chainService);
   } else {
-    return HistoryRecoverStatus.LACK_INFO;
+    return {
+      status: HistoryRecoverStatus.LACK_INFO
+    };
   }
 };
 exports.historyRecover = historyRecover;

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

@@ -17,7 +17,7 @@ var _subsquidMultiChainHistory = require("./subsquid-multi-chain-history");
 
 class HistoryService {
   historySubject = new _rxjs.BehaviorSubject([]);
-  #processingHistories = {};
+  #needRecoveryHistories = {};
   constructor(dbService, chainService, eventService, keyringService) {
     this.dbService = dbService;
     this.chainService = chainService;
@@ -80,7 +80,7 @@ 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());
   }
 
@@ -139,7 +139,7 @@ class HistoryService {
   }
   async recoverHistories() {
     const list = [];
-    for (const processingHistory of Object.values(this.#processingHistories)) {
+    for (const processingHistory of Object.values(this.#needRecoveryHistories)) {
       const chainState = this.chainService.getChainStateByKey(processingHistory.chain);
       if (chainState.active) {
         list.push(processingHistory);
@@ -149,24 +149,28 @@ class HistoryService {
       }
     }
     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) {
+    const results = await Promise.all(promises);
+    results.forEach((recoverResult, index) => {
+      const currentExtrinsicHash = list[index].extrinsicHash;
+      const updateData = {
+        ...recoverResult,
+        status: _KoniTypes.ExtrinsicStatus.UNKNOWN
+      };
+      switch (recoverResult.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];
+          updateData.status = recoverResult.status === _recoverHistoryStatus.HistoryRecoverStatus.SUCCESS ? _KoniTypes.ExtrinsicStatus.SUCCESS : _KoniTypes.ExtrinsicStatus.FAIL;
+          this.updateHistoryByExtrinsicHash(currentExtrinsicHash, updateData).catch(console.error);
+          delete this.#needRecoveryHistories[currentExtrinsicHash];
           break;
         default:
-          delete this.#processingHistories[extrinsicHash];
+          this.updateHistoryByExtrinsicHash(currentExtrinsicHash, updateData).catch(console.error);
+          delete this.#needRecoveryHistories[currentExtrinsicHash];
       }
     });
-    if (!Object.keys(this.#processingHistories).length) {
+    if (!Object.keys(this.#needRecoveryHistories).length) {
       await this.stopRecoverHistories();
     }
   }
@@ -176,7 +180,7 @@ class HistoryService {
     await this.loadData();
     Promise.all([this.eventService.waitKeyringReady, this.eventService.waitChainReady]).then(() => {
       this.getHistories().catch(console.log);
-      this.getProcessingHistory().catch(console.log);
+      this.recoverProcessingHistory().catch(console.error);
       this.eventService.on('account.add', () => {
         (async () => {
           await this.stopCron();
@@ -189,14 +193,18 @@ class HistoryService {
     }).catch(console.error);
     this.status = _types.ServiceStatus.INITIALIZED;
   }
-  async getProcessingHistory() {
+  async recoverProcessingHistory() {
     const histories = await this.dbService.getHistories();
-    this.#processingHistories = {};
+    this.#needRecoveryHistories = {};
     histories.filter(history => {
-      return history.status === 'processing';
+      return [_KoniTypes.ExtrinsicStatus.PROCESSING, _KoniTypes.ExtrinsicStatus.SUBMITTING].includes(history.status);
     }).forEach(history => {
-      this.#processingHistories[history.extrinsicHash] = 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() {
@@ -204,7 +212,6 @@ class HistoryService {
       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) {

package/cjs/services/notification-service/NotificationService.js

@@ -36,7 +36,7 @@ class NotificationService {
       type: 'basic',
       title,
       message,
-      iconUrl: 'https://subwallet.app/assets/images/favicon/favicon-192x192.png',
+      iconUrl: './images/icon-128.png',
       priority: 2,
       isClickable: !!link
     }, notificationId => {

package/cjs/services/storage-service/DatabaseService.js

@@ -120,7 +120,7 @@ class DatabaseService {
     const cleanedHistory = histories.filter(x => x && x.address && x.chain && x.extrinsicHash);
     return this.stores.transaction.bulkUpsert(cleanedHistory);
   }
-  async updateHistoryByNewExtrinsicHash(extrinsicHash, updateData) {
+  async updateHistoryByExtrinsicHash(extrinsicHash, updateData) {
     const canUpdate = updateData && extrinsicHash;
     if (!canUpdate) {
       return;

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

@@ -279,7 +279,7 @@ class TransactionService {
     const chainInfo = this.chainService.getChainInfoByKey(transaction.chain);
     return (0, _utils2.getExplorerLink)(chainInfo, transaction.extrinsicHash, 'tx');
   }
-  transactionToHistories(id, eventLogs) {
+  transactionToHistories(id, startBlock, nonce, eventLogs) {
     const transaction = this.getTransaction(id);
     const historyItem = {
       origin: 'app',
@@ -297,9 +297,12 @@ class TransactionService {
       fee: transaction.estimateFee,
       blockNumber: 0,
       // Will be added in next step
-      blockHash: '' // Will be added in next step
+      blockHash: '',
+      // Will be added in next step
+      nonce: nonce || 0,
+      startBlock: startBlock || 0
     };
-
+    console.log('historyItem', historyItem);
     const chainInfo = this.chainService.getChainInfoByKey(transaction.chain);
     const nativeAsset = (0, _utils._getChainNativeTokenBasicInfo)(chainInfo);
     const baseNativeAmount = {
@@ -468,7 +471,9 @@ class TransactionService {
   }
   onSend(_ref2) {
     let {
-      id
+      id,
+      nonce,
+      startBlock
     } = _ref2;
     // Update transaction status
     this.updateTransaction(id, {
@@ -476,7 +481,7 @@ class TransactionService {
     });
 
     // Create Input History Transaction History
-    this.historyService.insertHistories(this.transactionToHistories(id)).catch(console.error);
+    this.historyService.insertHistories(this.transactionToHistories(id, startBlock, nonce)).catch(console.error);
     console.debug(`Transaction "${id}" is sent`);
   }
   onHasTransactionHash(_ref3) {
@@ -527,15 +532,18 @@ class TransactionService {
     let {
       blockHash,
       blockNumber,
+      extrinsicHash,
       id
     } = _ref4;
     const transaction = this.getTransaction(id);
     this.updateTransaction(id, {
-      status: _KoniTypes.ExtrinsicStatus.SUCCESS
+      status: _KoniTypes.ExtrinsicStatus.SUCCESS,
+      extrinsicHash
     });
 
     // Write success transaction history
-    this.historyService.updateHistories(transaction.chain, transaction.extrinsicHash, {
+    this.historyService.updateHistoryByExtrinsicHash(transaction.extrinsicHash, {
+      extrinsicHash,
       status: _KoniTypes.ExtrinsicStatus.SUCCESS,
       blockNumber: blockNumber || 0,
       blockHash: blockHash || ''
@@ -556,6 +564,7 @@ class TransactionService {
       blockHash,
       blockNumber,
       errors,
+      extrinsicHash,
       id
     } = _ref5;
     const transaction = this.getTransaction(id);
@@ -563,11 +572,13 @@ class TransactionService {
     if (transaction) {
       this.updateTransaction(id, {
         status: nextStatus,
-        errors
+        errors,
+        extrinsicHash
       });
 
       // Write failed transaction history
-      this.historyService.updateHistories(transaction.chain, transaction.extrinsicHash, {
+      this.historyService.updateHistoryByExtrinsicHash(transaction.extrinsicHash, {
+        extrinsicHash: extrinsicHash || transaction.extrinsicHash,
         status: nextStatus,
         blockNumber: blockNumber || 0,
         blockHash: blockHash || ''
@@ -667,7 +678,7 @@ class TransactionService {
       errors: [],
       warnings: []
     };
-    this.requestService.addConfirmation(id, url || _constants2.EXTENSION_REQUEST_URL, 'evmSendTransactionRequest', payload, {}).then(_ref7 => {
+    this.requestService.addConfirmation(id, url || _constants2.EXTENSION_REQUEST_URL, 'evmSendTransactionRequest', payload, {}).then(async _ref7 => {
       let {
         isApproved,
         payload
@@ -694,11 +705,16 @@ class TransactionService {
 
         // Send transaction
         this.handleTransactionTimeout(emitter, eventData);
+
+        // Add start info
+        eventData.nonce = txObject.nonce;
+        eventData.startBlock = await web3Api.eth.getBlockNumber();
         emitter.emit('send', eventData); // This event is needed after sending transaction with queue
         signedTransaction && web3Api.eth.sendSignedTransaction(signedTransaction).once('transactionHash', hash => {
           eventData.extrinsicHash = hash;
           emitter.emit('extrinsicHash', eventData);
         }).once('receipt', rs => {
+          eventData.extrinsicHash = rs.transactionHash;
           eventData.blockHash = rs.blockHash;
           eventData.blockNumber = rs.blockNumber;
           emitter.emit('success', eventData);
@@ -724,6 +740,7 @@ class TransactionService {
   signAndSendSubstrateTransaction(_ref8) {
     let {
       address,
+      chain,
       id,
       transaction,
       url
@@ -744,11 +761,14 @@ class TransactionService {
           };
         }
       }
-    }).then(rs => {
+    }).then(async rs => {
       // Emit signed event
       emitter.emit('signed', eventData);
 
       // Send transaction
+      const api = this.chainService.getSubstrateApi(chain);
+      eventData.nonce = rs.nonce.toNumber();
+      eventData.startBlock = (await api.api.query.system.number()).toPrimitive();
       this.handleTransactionTimeout(emitter, eventData);
       emitter.emit('send', eventData); // This event is needed after sending transaction with queue
 
@@ -766,6 +786,7 @@ class TransactionService {
           }
         }
         if (txState.status.isFinalized) {
+          eventData.extrinsicHash = txState.txHash.toHex();
           eventData.eventLogs = txState.events;
           // TODO: push block hash and block number into eventData
           txState.events.filter(_ref9 => {

package/cjs/utils/index.js

@@ -56,6 +56,9 @@ function reformatAddress(address) {
   let networkPrefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 42;
   let isEthereum = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
   try {
+    if (!address || address === '') {
+      return '';
+    }
     if ((0, _utilCrypto.isEthereumAddress)(address)) {
       return address;
     }

package/koni/background/handlers/Extension.js

@@ -1251,7 +1251,7 @@ export default class KoniExtension {
     const isPasswordValidated = this.validatedAccountsPassword(file, password);
     if (isPasswordValidated) {
       try {
-        this._saveCurrentAccountAddress(addressList[0], () => {
+        this._saveCurrentAccountAddress(ALL_ACCOUNT_KEY, () => {
           keyring.restoreAccounts(file, password);
           this._addAddressesToAuthList(addressList, isAllowed);
         });

package/package.json

@@ -17,7 +17,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "1.0.5-1",
+  "version": "1.0.5-2",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",
@@ -1693,10 +1693,10 @@
     "@subsocial/types": "^0.6.8",
     "@substrate/connect": "^0.7.26",
     "@subwallet/chain-list": "^0.1.2",
-    "@subwallet/extension-base": "^1.0.5-1",
-    "@subwallet/extension-chains": "^1.0.5-1",
-    "@subwallet/extension-dapp": "^1.0.5-1",
-    "@subwallet/extension-inject": "^1.0.5-1",
+    "@subwallet/extension-base": "^1.0.5-2",
+    "@subwallet/extension-chains": "^1.0.5-2",
+    "@subwallet/extension-dapp": "^1.0.5-2",
+    "@subwallet/extension-inject": "^1.0.5-2",
     "@subwallet/keyring": "^0.0.9",
     "@subwallet/ui-keyring": "^0.0.9",
     "@unique-nft/types": "^0.6.0-4",

package/packageInfo.js

@@ -7,5 +7,5 @@ export const packageInfo = {
   name: '@subwallet/extension-base',
   path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto',
   type: 'esm',
-  version: '1.0.5-1'
+  version: '1.0.5-2'
 };

package/services/history-service/helpers/recoverHistoryStatus.d.ts

@@ -8,4 +8,10 @@ export declare enum HistoryRecoverStatus {
     FAIL_DETECT = "FAIL_DETECT",
     UNKNOWN = "UNKNOWN"
 }
-export declare const historyRecover: (history: TransactionHistoryItem, chainService: ChainService) => Promise<HistoryRecoverStatus>;
+export interface TransactionRecoverResult {
+    status: HistoryRecoverStatus;
+    extrinsicHash?: string;
+    blockHash?: string;
+    blockNumber?: number;
+}
+export declare const historyRecover: (history: TransactionHistoryItem, chainService: ChainService) => Promise<TransactionRecoverResult>;

package/services/history-service/helpers/recoverHistoryStatus.js

@@ -1,6 +1,7 @@
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import { isSameAddress } from '@subwallet/extension-base/utils';
 export let HistoryRecoverStatus;
 (function (HistoryRecoverStatus) {
   HistoryRecoverStatus["SUCCESS"] = "SUCCESS";
@@ -10,75 +11,188 @@ export let HistoryRecoverStatus;
   HistoryRecoverStatus["FAIL_DETECT"] = "FAIL_DETECT";
   HistoryRecoverStatus["UNKNOWN"] = "UNKNOWN";
 })(HistoryRecoverStatus || (HistoryRecoverStatus = {}));
+const BLOCK_LIMIT = 6;
 const substrateRecover = async (history, chainService) => {
   const {
+    address,
     blockHash,
     chain,
-    extrinsicHash
+    extrinsicHash,
+    from,
+    nonce,
+    startBlock
   } = history;
+  const result = {
+    status: HistoryRecoverStatus.UNKNOWN
+  };
   try {
     const substrateApi = chainService.getSubstrateApi(chain);
     if (substrateApi) {
       const _api = await substrateApi.isReady;
       const api = _api.api;
       if (!blockHash) {
-        console.log(`Fail to find extrinsic ${extrinsicHash} on ${chain}: No block hash`);
-        return HistoryRecoverStatus.LACK_INFO;
-      }
-      const block = await api.rpc.chain.getBlock(blockHash);
-      const allEvents = await api.query.system.events.at(blockHash);
-      const extrinsics = block.block.extrinsics;
-      let index;
-      extrinsics.forEach((extrinsic, _idx) => {
-        if (extrinsicHash === extrinsic.hash.toHex()) {
-          index = _idx;
+        if (!nonce || !startBlock) {
+          console.log(`Fail to find extrinsic for ${address} on ${chain}: With nonce ${nonce || 'undefined'} from block ${startBlock || 'undefined'}`);
+          return {
+            status: HistoryRecoverStatus.LACK_INFO
+          };
         }
-      });
-      if (index === undefined) {
-        console.log(`Fail to find extrinsic ${extrinsicHash} on ${chain}`);
-        return HistoryRecoverStatus.FAIL_DETECT;
-      }
-      const events = allEvents.filter(({
-        phase
-      }) => phase.isApplyExtrinsic && phase.asApplyExtrinsic.eq(index));
-      for (const {
-        event
-      } of events) {
-        if (api.events.system.ExtrinsicSuccess.is(event)) {
-          return HistoryRecoverStatus.SUCCESS;
-        } else if (api.events.system.ExtrinsicFailed.is(event)) {
-          return HistoryRecoverStatus.FAILED;
+        const currentBlock = (await api.query.system.number()).toPrimitive();
+        for (let i = 1, found = false; i < BLOCK_LIMIT && !found && startBlock + i <= currentBlock; i++) {
+          const blockHash = (await api.rpc.chain.getBlockHash(startBlock + i)).toHex();
+          const block = await api.rpc.chain.getBlock(blockHash);
+          const extrinsics = block.block.extrinsics;
+          let index;
+          for (const [idx, extrinsic] of Object.entries(extrinsics)) {
+            if (extrinsic.signer && isSameAddress(from, extrinsic.signer.toString()) && nonce === extrinsic.nonce.toNumber()) {
+              index = parseInt(idx);
+              found = true;
+              result.extrinsicHash = extrinsic.hash.toHex();
+              result.blockHash = block.block.hash.toHex();
+              result.blockNumber = block.block.header.number.toNumber();
+              break;
+            }
+          }
+          if (index !== undefined) {
+            const allEvents = await api.query.system.events.at(blockHash);
+            const events = allEvents.filter(({
+              phase
+            }) => phase.isApplyExtrinsic && phase.asApplyExtrinsic.eq(index));
+            for (const {
+              event
+            } of events) {
+              if (api.events.system.ExtrinsicSuccess.is(event)) {
+                return {
+                  ...result,
+                  status: HistoryRecoverStatus.SUCCESS
+                };
+              } else if (api.events.system.ExtrinsicFailed.is(event)) {
+                return {
+                  ...result,
+                  status: HistoryRecoverStatus.FAILED
+                };
+              }
+            }
+          }
+        }
+      } else {
+        const block = await api.rpc.chain.getBlock(blockHash);
+        const allEvents = await api.query.system.events.at(blockHash);
+        const extrinsics = block.block.extrinsics;
+        let index;
+        for (const [idx, extrinsic] of Object.entries(extrinsics)) {
+          if (extrinsicHash === extrinsic.hash.toHex()) {
+            index = parseInt(idx);
+            break;
+          }
+        }
+        if (index === undefined) {
+          console.log(`Fail to find extrinsic ${extrinsicHash} on ${chain}`);
+          return {
+            status: HistoryRecoverStatus.FAIL_DETECT
+          };
+        }
+        const events = allEvents.filter(({
+          phase
+        }) => phase.isApplyExtrinsic && phase.asApplyExtrinsic.eq(index));
+        for (const {
+          event
+        } of events) {
+          if (api.events.system.ExtrinsicSuccess.is(event)) {
+            return {
+              ...result,
+              status: HistoryRecoverStatus.SUCCESS
+            };
+          } else if (api.events.system.ExtrinsicFailed.is(event)) {
+            return {
+              ...result,
+              status: HistoryRecoverStatus.FAILED
+            };
+          }
         }
       }
-      return HistoryRecoverStatus.FAIL_DETECT;
+      return {
+        status: HistoryRecoverStatus.FAIL_DETECT
+      };
     } else {
       console.error(`Fail to update history ${chain}-${extrinsicHash}: Api not active`);
-      return HistoryRecoverStatus.API_INACTIVE;
+      return {
+        status: HistoryRecoverStatus.API_INACTIVE
+      };
     }
   } catch (e) {
     console.error(`Fail to update history ${chain}-${extrinsicHash}:`, e.message);
-    return HistoryRecoverStatus.UNKNOWN;
+    return {
+      status: HistoryRecoverStatus.UNKNOWN
+    };
   }
 };
 const evmRecover = async (history, chainService) => {
   const {
+    address,
     chain,
-    extrinsicHash
+    extrinsicHash,
+    from,
+    nonce,
+    startBlock
   } = history;
+  const result = {
+    status: HistoryRecoverStatus.UNKNOWN
+  };
   try {
     const evmApi = chainService.getEvmApi(chain);
     if (evmApi) {
       const _api = await evmApi.isReady;
       const api = _api.api;
-      const block = await api.eth.getTransactionReceipt(extrinsicHash);
-      return block.status ? HistoryRecoverStatus.SUCCESS : HistoryRecoverStatus.FAILED;
+      if (extrinsicHash) {
+        const transactionReceipt = await api.eth.getTransactionReceipt(extrinsicHash);
+        return {
+          ...result,
+          status: transactionReceipt.status ? HistoryRecoverStatus.SUCCESS : HistoryRecoverStatus.FAILED
+        };
+      } else {
+        if (!nonce || !startBlock) {
+          console.log(`Fail to find extrinsic for ${address} on ${chain}: With nonce ${nonce || 'undefined'} from block ${startBlock || 'undefined'}`);
+          return {
+            ...result,
+            status: HistoryRecoverStatus.LACK_INFO
+          };
+        }
+        const currentBlock = await api.eth.getBlockNumber();
+        for (let i = 1, found = false; i < BLOCK_LIMIT && !found && startBlock + i <= currentBlock; i++) {
+          const block = await api.eth.getBlock(startBlock + i, true);
+          for (const transaction of block.transactions) {
+            if (isSameAddress(transaction.from, from) && nonce === transaction.nonce) {
+              result.extrinsicHash = transaction.hash;
+              result.blockHash = block.hash;
+              result.blockNumber = block.number;
+              found = true;
+              break;
+            }
+          }
+          if (result.extrinsicHash) {
+            const transactionReceipt = await api.eth.getTransactionReceipt(result.extrinsicHash);
+            return {
+              ...result,
+              status: transactionReceipt.status ? HistoryRecoverStatus.SUCCESS : HistoryRecoverStatus.FAILED
+            };
+          }
+        }
+      }
+      return {
+        status: HistoryRecoverStatus.FAIL_DETECT
+      };
     } else {
       console.error(`Fail to update history ${chain}-${extrinsicHash}: Api not active`);
-      return HistoryRecoverStatus.API_INACTIVE;
+      return {
+        status: HistoryRecoverStatus.API_INACTIVE
+      };
     }
   } catch (e) {
     console.error(`Fail to update history ${chain}-${extrinsicHash}:`, e.message);
-    return HistoryRecoverStatus.UNKNOWN;
+    return {
+      status: HistoryRecoverStatus.UNKNOWN
+    };
   }
 };
 
@@ -93,6 +207,8 @@ export const historyRecover = async (history, chainService) => {
     const checkFunction = chainType === 'substrate' ? substrateRecover : evmRecover;
     return await checkFunction(history, chainService);
   } else {
-    return HistoryRecoverStatus.LACK_INFO;
+    return {
+      status: HistoryRecoverStatus.LACK_INFO
+    };
   }
 };

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

@@ -38,7 +38,7 @@ export declare class HistoryService implements StoppableServiceInterface, Persis
         promise: Promise<void>;
     };
     init(): Promise<void>;
-    getProcessingHistory(): Promise<void>;
+    recoverProcessingHistory(): Promise<void>;
     start(): Promise<void>;
     waitForStarted(): Promise<void>;
     stopPromiseHandler: {

package/services/history-service/index.js

@@ -11,7 +11,7 @@ import { BehaviorSubject } from 'rxjs';
 import { fetchMultiChainHistories } from "./subsquid-multi-chain-history.js";
 export class HistoryService {
   historySubject = new BehaviorSubject([]);
-  #processingHistories = {};
+  #needRecoveryHistories = {};
   constructor(dbService, chainService, eventService, keyringService) {
     this.dbService = dbService;
     this.chainService = chainService;
@@ -73,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());
   }
 
@@ -132,7 +132,7 @@ export class HistoryService {
   }
   async recoverHistories() {
     const list = [];
-    for (const processingHistory of Object.values(this.#processingHistories)) {
+    for (const processingHistory of Object.values(this.#needRecoveryHistories)) {
       const chainState = this.chainService.getChainStateByKey(processingHistory.chain);
       if (chainState.active) {
         list.push(processingHistory);
@@ -142,24 +142,28 @@ export class HistoryService {
       }
     }
     const promises = list.map(history => historyRecover(history, this.chainService));
-    const result = await Promise.all(promises);
-    result.forEach((status, index) => {
-      const extrinsicHash = list[index].extrinsicHash;
-      switch (status) {
+    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:
-          this.updateHistoryByExtrinsicHash(extrinsicHash, {
-            status: status === HistoryRecoverStatus.SUCCESS ? ExtrinsicStatus.SUCCESS : ExtrinsicStatus.FAIL
-          }).catch(console.error);
-          delete this.#processingHistories[extrinsicHash];
+          updateData.status = recoverResult.status === HistoryRecoverStatus.SUCCESS ? ExtrinsicStatus.SUCCESS : ExtrinsicStatus.FAIL;
+          this.updateHistoryByExtrinsicHash(currentExtrinsicHash, updateData).catch(console.error);
+          delete this.#needRecoveryHistories[currentExtrinsicHash];
           break;
         default:
-          delete this.#processingHistories[extrinsicHash];
+          this.updateHistoryByExtrinsicHash(currentExtrinsicHash, updateData).catch(console.error);
+          delete this.#needRecoveryHistories[currentExtrinsicHash];
       }
     });
-    if (!Object.keys(this.#processingHistories).length) {
+    if (!Object.keys(this.#needRecoveryHistories).length) {
       await this.stopRecoverHistories();
     }
   }
@@ -169,7 +173,7 @@ export class HistoryService {
     await this.loadData();
     Promise.all([this.eventService.waitKeyringReady, this.eventService.waitChainReady]).then(() => {
       this.getHistories().catch(console.log);
-      this.getProcessingHistory().catch(console.log);
+      this.recoverProcessingHistory().catch(console.error);
       this.eventService.on('account.add', () => {
         (async () => {
           await this.stopCron();
@@ -182,14 +186,18 @@ export class HistoryService {
     }).catch(console.error);
     this.status = ServiceStatus.INITIALIZED;
   }
-  async getProcessingHistory() {
+  async recoverProcessingHistory() {
     const histories = await this.dbService.getHistories();
-    this.#processingHistories = {};
+    this.#needRecoveryHistories = {};
     histories.filter(history => {
-      return history.status === 'processing';
+      return [ExtrinsicStatus.PROCESSING, ExtrinsicStatus.SUBMITTING].includes(history.status);
     }).forEach(history => {
-      this.#processingHistories[history.extrinsicHash] = 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() {
@@ -197,7 +205,6 @@ export class HistoryService {
       this.startPromiseHandler = createPromiseHandler();
       this.status = ServiceStatus.STARTING;
       await this.startCron();
-      await this.startRecoverHistories();
       this.status = ServiceStatus.STARTED;
       this.startPromiseHandler.resolve();
     } catch (e) {

package/services/notification-service/NotificationService.js

@@ -30,7 +30,7 @@ export default class NotificationService {
       type: 'basic',
       title,
       message,
-      iconUrl: 'https://subwallet.app/assets/images/favicon/favicon-192x192.png',
+      iconUrl: './images/icon-128.png',
       priority: 2,
       isClickable: !!link
     }, notificationId => {

package/services/storage-service/DatabaseService.d.ts

@@ -41,7 +41,7 @@ export default class DatabaseService {
     subscribeNominatorMetadata(callback: (data: NominatorMetadata[]) => void): void;
     getHistories(query?: HistoryQuery): Promise<import("@subwallet/extension-base/services/storage-service/databases").ITransactionHistoryItem[]>;
     upsertHistory(histories: TransactionHistoryItem[]): Promise<unknown>;
-    updateHistoryByNewExtrinsicHash(extrinsicHash: string, updateData: Partial<TransactionHistoryItem>): Promise<unknown>;
+    updateHistoryByExtrinsicHash(extrinsicHash: string, updateData: Partial<TransactionHistoryItem>): Promise<unknown>;
     addNftCollection(collection: NftCollection): Promise<unknown>;
     deleteNftCollection(chain: string, collectionId: string): Promise<void>;
     getAllNftCollection(chainHashes?: string[]): import("dexie").PromiseExtended<NftCollection[]>;

package/services/storage-service/DatabaseService.js

@@ -113,7 +113,7 @@ export default class DatabaseService {
     const cleanedHistory = histories.filter(x => x && x.address && x.chain && x.extrinsicHash);
     return this.stores.transaction.bulkUpsert(cleanedHistory);
   }
-  async updateHistoryByNewExtrinsicHash(extrinsicHash, updateData) {
+  async updateHistoryByExtrinsicHash(extrinsicHash, updateData) {
     const canUpdate = updateData && extrinsicHash;
     if (!canUpdate) {
       return;

package/services/transaction-service/index.js

@@ -272,7 +272,7 @@ export default class TransactionService {
     const chainInfo = this.chainService.getChainInfoByKey(transaction.chain);
     return getExplorerLink(chainInfo, transaction.extrinsicHash, 'tx');
   }
-  transactionToHistories(id, eventLogs) {
+  transactionToHistories(id, startBlock, nonce, eventLogs) {
     const transaction = this.getTransaction(id);
     const historyItem = {
       origin: 'app',
@@ -290,9 +290,12 @@ export default class TransactionService {
       fee: transaction.estimateFee,
       blockNumber: 0,
       // Will be added in next step
-      blockHash: '' // Will be added in next step
+      blockHash: '',
+      // Will be added in next step
+      nonce: nonce || 0,
+      startBlock: startBlock || 0
     };
-
+    console.log('historyItem', historyItem);
     const chainInfo = this.chainService.getChainInfoByKey(transaction.chain);
     const nativeAsset = _getChainNativeTokenBasicInfo(chainInfo);
     const baseNativeAmount = {
@@ -459,7 +462,9 @@ export default class TransactionService {
     console.debug(`Transaction "${id}" is signed`);
   }
   onSend({
-    id
+    id,
+    nonce,
+    startBlock
   }) {
     // Update transaction status
     this.updateTransaction(id, {
@@ -467,7 +472,7 @@ export default class TransactionService {
     });
 
     // Create Input History Transaction History
-    this.historyService.insertHistories(this.transactionToHistories(id)).catch(console.error);
+    this.historyService.insertHistories(this.transactionToHistories(id, startBlock, nonce)).catch(console.error);
     console.debug(`Transaction "${id}" is sent`);
   }
   onHasTransactionHash({
@@ -516,15 +521,18 @@ export default class TransactionService {
   onSuccess({
     blockHash,
     blockNumber,
+    extrinsicHash,
     id
   }) {
     const transaction = this.getTransaction(id);
     this.updateTransaction(id, {
-      status: ExtrinsicStatus.SUCCESS
+      status: ExtrinsicStatus.SUCCESS,
+      extrinsicHash
     });
 
     // Write success transaction history
-    this.historyService.updateHistories(transaction.chain, transaction.extrinsicHash, {
+    this.historyService.updateHistoryByExtrinsicHash(transaction.extrinsicHash, {
+      extrinsicHash,
       status: ExtrinsicStatus.SUCCESS,
       blockNumber: blockNumber || 0,
       blockHash: blockHash || ''
@@ -544,6 +552,7 @@ export default class TransactionService {
     blockHash,
     blockNumber,
     errors,
+    extrinsicHash,
     id
   }) {
     const transaction = this.getTransaction(id);
@@ -551,11 +560,13 @@ export default class TransactionService {
     if (transaction) {
       this.updateTransaction(id, {
         status: nextStatus,
-        errors
+        errors,
+        extrinsicHash
       });
 
       // Write failed transaction history
-      this.historyService.updateHistories(transaction.chain, transaction.extrinsicHash, {
+      this.historyService.updateHistoryByExtrinsicHash(transaction.extrinsicHash, {
+        extrinsicHash: extrinsicHash || transaction.extrinsicHash,
         status: nextStatus,
         blockNumber: blockNumber || 0,
         blockHash: blockHash || ''
@@ -654,7 +665,7 @@ export default class TransactionService {
       errors: [],
       warnings: []
     };
-    this.requestService.addConfirmation(id, url || EXTENSION_REQUEST_URL, 'evmSendTransactionRequest', payload, {}).then(({
+    this.requestService.addConfirmation(id, url || EXTENSION_REQUEST_URL, 'evmSendTransactionRequest', payload, {}).then(async ({
       isApproved,
       payload
     }) => {
@@ -680,11 +691,16 @@ export default class TransactionService {
 
         // Send transaction
         this.handleTransactionTimeout(emitter, eventData);
+
+        // Add start info
+        eventData.nonce = txObject.nonce;
+        eventData.startBlock = await web3Api.eth.getBlockNumber();
         emitter.emit('send', eventData); // This event is needed after sending transaction with queue
         signedTransaction && web3Api.eth.sendSignedTransaction(signedTransaction).once('transactionHash', hash => {
           eventData.extrinsicHash = hash;
           emitter.emit('extrinsicHash', eventData);
         }).once('receipt', rs => {
+          eventData.extrinsicHash = rs.transactionHash;
           eventData.blockHash = rs.blockHash;
           eventData.blockNumber = rs.blockNumber;
           emitter.emit('success', eventData);
@@ -709,6 +725,7 @@ export default class TransactionService {
   }
   signAndSendSubstrateTransaction({
     address,
+    chain,
     id,
     transaction,
     url
@@ -729,11 +746,14 @@ export default class TransactionService {
           };
         }
       }
-    }).then(rs => {
+    }).then(async rs => {
       // Emit signed event
       emitter.emit('signed', eventData);
 
       // Send transaction
+      const api = this.chainService.getSubstrateApi(chain);
+      eventData.nonce = rs.nonce.toNumber();
+      eventData.startBlock = (await api.api.query.system.number()).toPrimitive();
       this.handleTransactionTimeout(emitter, eventData);
       emitter.emit('send', eventData); // This event is needed after sending transaction with queue
 
@@ -751,6 +771,7 @@ export default class TransactionService {
           }
         }
         if (txState.status.isFinalized) {
+          eventData.extrinsicHash = txState.txHash.toHex();
           eventData.eventLogs = txState.events;
           // TODO: push block hash and block number into eventData
           txState.events.filter(({

package/services/transaction-service/types.d.ts

@@ -39,6 +39,8 @@ export interface TransactionEventResponse extends ValidateTransactionResponse {
     blockHash?: string;
     blockNumber?: number;
     eventLogs?: EventRecord[];
+    nonce?: number;
+    startBlock?: number;
 }
 export interface TransactionEventMap {
     send: (response: TransactionEventResponse) => void;

package/utils/index.js

@@ -15,6 +15,9 @@ export function isAccountAll(address) {
 }
 export function reformatAddress(address, networkPrefix = 42, isEthereum = false) {
   try {
+    if (!address || address === '') {
+      return '';
+    }
     if (isEthereumAddress(address)) {
       return address;
     }