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

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/history-service/subsquid-multi-chain-history.js

@@ -244,7 +244,7 @@ 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}`); // TODO: resolve conflicting chainId
+      console.debug(`Not found chain info for chain id: ${chainId}`); // TODO: resolve conflicting chainId
 
       return;
     }
@@ -253,7 +253,7 @@ export async function fetchMultiChainHistories(addresses, chainMap, maxPage = 25
         const transactionData = parseSubsquidTransactionData(address, name, historyItem, chainInfo, parseData(args), parseData(_data));
         histories.push(transactionData);
       } catch (e) {
-        console.warn('Parse transaction data failed', address, e);
+        console.debug('Parse transaction data failed', address, 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

@@ -161,8 +161,8 @@ export default class TransactionService {
     const transactionId = getTransactionId(transaction.chainType, transaction.chain, isInternal);
     return {
       ...transaction,
-      createdAt: new Date(),
-      updatedAt: new Date(),
+      createdAt: new Date().getTime(),
+      updatedAt: new Date().getTime(),
       errors: transaction.errors || [],
       warnings: transaction.warnings || [],
       url: transaction.url || EXTENSION_REQUEST_URL,
@@ -203,6 +203,9 @@ export default class TransactionService {
     const stopByErrors = validatedTransaction.errors.length > 0;
     const stopByWarnings = validatedTransaction.warnings.length > 0 && !validatedTransaction.ignoreWarnings;
     if (stopByErrors || stopByWarnings) {
+      // @ts-ignore
+      'transaction' in validatedTransaction && delete validatedTransaction.transaction;
+      'additionalValidator' in validatedTransaction && delete validatedTransaction.additionalValidator;
       return validatedTransaction;
     }
     validatedTransaction.warnings = [];
@@ -220,6 +223,10 @@ export default class TransactionService {
         }
       });
     });
+
+    // @ts-ignore
+    'transaction' in validatedTransaction && delete validatedTransaction.transaction;
+    'additionalValidator' in validatedTransaction && delete validatedTransaction.additionalValidator;
     return validatedTransaction;
   }
   async sendTransaction(transaction) {
@@ -272,7 +279,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',
@@ -286,13 +293,15 @@ export default class TransactionService {
       status: transaction.status,
       transactionId: transaction.id,
       extrinsicHash: transaction.extrinsicHash,
-      time: transaction.createdAt.getTime(),
+      time: transaction.createdAt,
       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
     };
-
     const chainInfo = this.chainService.getChainInfoByKey(transaction.chain);
     const nativeAsset = _getChainNativeTokenBasicInfo(chainInfo);
     const baseNativeAmount = {
@@ -459,7 +468,9 @@ export default class TransactionService {
     console.debug(`Transaction "${id}" is signed`);
   }
   onSend({
-    id
+    id,
+    nonce,
+    startBlock
   }) {
     // Update transaction status
     this.updateTransaction(id, {
@@ -467,7 +478,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 +527,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 +558,7 @@ export default class TransactionService {
     blockHash,
     blockNumber,
     errors,
+    extrinsicHash,
     id
   }) {
     const transaction = this.getTransaction(id);
@@ -551,11 +566,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 +671,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 +697,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 +731,7 @@ export default class TransactionService {
   }
   signAndSendSubstrateTransaction({
     address,
+    chain,
     id,
     transaction,
     url
@@ -729,11 +752,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 +777,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

@@ -14,14 +14,14 @@ export interface SWTransaction extends ValidateTransactionResponse, Partial<Pick
     status: ExtrinsicStatus;
     extrinsicHash: string;
     extrinsicType: ExtrinsicType;
-    createdAt: Date;
-    updatedAt: Date;
+    createdAt: number;
+    updatedAt: number;
     estimateFee?: AmountData;
     transaction: SubmittableExtrinsic | TransactionConfig;
     additionalValidator?: (inputTransaction: SWTransactionResponse) => Promise<void>;
     eventsHandler?: (eventEmitter: TransactionEmitter) => void;
 }
-export declare type SWTransactionResult = Omit<SWTransaction, 'transaction'>;
+export declare type SWTransactionResult = Omit<SWTransaction, 'transaction' | 'additionalValidator'>;
 declare type SwInputBase = Pick<SWTransaction, 'address' | 'url' | 'data' | 'extrinsicType' | 'chain' | 'chainType' | 'ignoreWarnings' | 'transferNativeAmount'> & Partial<Pick<SWTransaction, 'additionalValidator'>>;
 export interface SWTransactionInput extends SwInputBase {
     transaction?: SWTransaction['transaction'] | null;
@@ -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/services/transaction-service/utils.js

@@ -21,6 +21,9 @@ function getBlockExplorerTxRoute(chainInfo) {
   if (_isPureEvmChain(chainInfo)) {
     return 'tx';
   }
+  if (['aventus'].includes(chainInfo.slug)) {
+    return 'transaction';
+  }
   return 'extrinsic';
 }
 export function getExplorerLink(chainInfo, value, type) {

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;
     }