@subwallet/extension-base 1.0.2-3 → 1.0.3-0

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

@@ -1,10 +1,11 @@
 import { TransactionHistoryItem } from '@subwallet/extension-base/background/KoniTypes';
+import { CronServiceInterface, PersistDataServiceInterface, ServiceStatus, StoppableServiceInterface } from '@subwallet/extension-base/services/base/types';
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
 import { EventService } from '@subwallet/extension-base/services/event-service';
 import { KeyringService } from '@subwallet/extension-base/services/keyring-service';
 import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
 import { BehaviorSubject } from 'rxjs';
-export declare class HistoryService {
+export declare class HistoryService implements StoppableServiceInterface, PersistDataServiceInterface, CronServiceInterface {
     private dbService;
     private chainService;
     private eventService;
@@ -12,15 +13,33 @@ export declare class HistoryService {
     private historySubject;
     constructor(dbService: DatabaseService, chainService: ChainService, eventService: EventService, keyringService: KeyringService);
     private fetchPromise;
-    private nextFetch;
+    private interval;
     private fetchAndLoadHistories;
-    fetchHistories(addresses: string[]): Promise<TransactionHistoryItem<import("@subwallet/extension-base/background/KoniTypes").ExtrinsicType.TRANSFER_BALANCE>[]>;
-    invalidCache(): void;
-    refreshHistoryInterval(): void;
     getHistories(): Promise<TransactionHistoryItem<import("@subwallet/extension-base/background/KoniTypes").ExtrinsicType.TRANSFER_BALANCE>[]>;
     getHistorySubject(): Promise<BehaviorSubject<TransactionHistoryItem<import("@subwallet/extension-base/background/KoniTypes").ExtrinsicType.TRANSFER_BALANCE>[]>>;
     updateHistories(chain: string, extrinsicHash: string, updateData: Partial<TransactionHistoryItem>): Promise<void>;
+    updateHistoryByExtrinsicHash(extrinsicHash: string, updateData: Partial<TransactionHistoryItem>): Promise<void>;
     insertHistories(historyItems: TransactionHistoryItem[]): Promise<void>;
     addHistoryItems(historyItems: TransactionHistoryItem[]): Promise<void>;
     removeHistoryByAddress(address: string): Promise<void>;
+    status: ServiceStatus;
+    loadData(): Promise<void>;
+    persistData(): Promise<void>;
+    startCron(): Promise<void>;
+    stopCron(): Promise<void>;
+    startPromiseHandler: {
+        resolve: (value: void) => void;
+        reject: (reason?: unknown) => void;
+        promise: Promise<void>;
+    };
+    init(): Promise<void>;
+    start(): Promise<void>;
+    waitForStarted(): Promise<void>;
+    stopPromiseHandler: {
+        resolve: (value: void) => void;
+        reject: (reason?: unknown) => void;
+        promise: Promise<void>;
+    };
+    stop(): Promise<void>;
+    waitForStopped(): Promise<void>;
 }

package/services/history-service/index.js

@@ -2,6 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { CRON_REFRESH_HISTORY_INTERVAL } from '@subwallet/extension-base/constants';
+import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
+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";
@@ -12,24 +14,10 @@ export class HistoryService {
     this.chainService = chainService;
     this.eventService = eventService;
     this.keyringService = keyringService;
-    // Load history from database
-    this.dbService.getHistories().then(histories => {
-      this.historySubject.next(histories);
-    }).catch(console.error);
-
-    // 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);
+    this.init().catch(console.error);
   }
   fetchPromise = null;
-  nextFetch = undefined;
+  interval = undefined;
   async fetchAndLoadHistories(addresses) {
     if (!addresses || addresses.length === 0) {
       return [];
@@ -52,32 +40,16 @@ export class HistoryService {
     await this.addHistoryItems(historyRecords);
     return historyRecords;
   }
-  async fetchHistories(addresses) {
-    if (!this.fetchPromise) {
-      // Fetch another histories data data indexer and merge it with stored in database
-      this.fetchPromise = this.fetchAndLoadHistories(addresses);
-    }
-    return this.fetchPromise;
-  }
-  invalidCache() {
-    this.fetchPromise = null;
-  }
-  refreshHistoryInterval() {
-    clearTimeout(this.nextFetch);
-    this.invalidCache();
-    this.getHistories().catch(console.error);
-    this.nextFetch = setTimeout(() => {
-      this.refreshHistoryInterval();
-    }, CRON_REFRESH_HISTORY_INTERVAL);
-  }
   async getHistories() {
     const addressList = 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());
+    if (!this.fetchPromise) {
+      this.fetchPromise = (async () => {
+        await this.fetchAndLoadHistories(addressList);
+        const histories = await this.dbService.getHistories();
+        this.historySubject.next(histories);
+      })();
     }
-    return this.historySubject.getValue();
+    return Promise.resolve(this.historySubject.getValue());
   }
   async getHistorySubject() {
     await this.getHistories();
@@ -96,6 +68,10 @@ export class HistoryService {
     });
     await this.addHistoryItems(updatedRecords);
   }
+  async updateHistoryByExtrinsicHash(extrinsicHash, updateData) {
+    await this.dbService.updateHistoryByNewExtrinsicHash(extrinsicHash, updateData);
+    this.historySubject.next(await this.dbService.getHistories());
+  }
 
   // Insert history without check override origin 'app'
   async insertHistories(historyItems) {
@@ -124,4 +100,73 @@ export class HistoryService {
     await this.dbService.stores.transaction.removeAllByAddress(address);
     this.historySubject.next(await this.dbService.getHistories());
   }
+  status = ServiceStatus.NOT_INITIALIZED;
+  async loadData() {
+    const histories = await this.dbService.getHistories();
+    this.historySubject.next(histories);
+  }
+  async persistData() {
+    await this.dbService.upsertHistory(this.historySubject.value);
+  }
+  async startCron() {
+    await this.getHistories();
+    this.interval = setInterval(() => {
+      this.getHistories().catch(console.error);
+    }, CRON_REFRESH_HISTORY_INTERVAL);
+  }
+  stopCron() {
+    clearTimeout(this.interval);
+    this.fetchPromise = null;
+    return Promise.resolve();
+  }
+  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.eventService.on('account.add', () => {
+        (async () => {
+          await this.stopCron();
+          await this.startCron();
+        })().catch(console.error);
+      });
+      this.eventService.on('account.remove', address => {
+        this.removeHistoryByAddress(address).catch(console.error);
+      });
+    }).catch(console.error);
+    this.status = ServiceStatus.INITIALIZED;
+  }
+  async start() {
+    try {
+      console.debug('Start history service');
+      this.startPromiseHandler = createPromiseHandler();
+      this.status = ServiceStatus.STARTING;
+      await this.startCron();
+      this.status = ServiceStatus.STARTED;
+      this.startPromiseHandler.resolve();
+    } catch (e) {
+      this.startPromiseHandler.reject(e);
+    }
+  }
+  waitForStarted() {
+    return this.startPromiseHandler.promise;
+  }
+  stopPromiseHandler = createPromiseHandler();
+  async stop() {
+    console.debug('Stop history service');
+    try {
+      this.stopPromiseHandler = createPromiseHandler();
+      this.status = ServiceStatus.STOPPING;
+      await this.persistData();
+      await this.stopCron();
+      this.stopPromiseHandler.resolve();
+      this.status = ServiceStatus.STOPPED;
+    } catch (e) {
+      this.stopPromiseHandler.reject(e);
+    }
+  }
+  waitForStopped() {
+    return this.stopPromiseHandler.promise;
+  }
 }

package/services/migration-service/scripts/MigrateImportedToken.js

@@ -25,7 +25,8 @@ export default class MigrateImportedToken extends BaseMigrationJob {
                   originChain: item.chain,
                   priceId: null,
                   slug: '',
-                  symbol: item.symbol || ''
+                  symbol: item.symbol || '',
+                  icon: ''
                 });
               } catch (e) {
                 console.log(e);

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

@@ -1,9 +1,11 @@
 import { PriceJson } from '@subwallet/extension-base/background/KoniTypes';
+import { CronServiceInterface, PersistDataServiceInterface, ServiceStatus, StoppableServiceInterface } from '@subwallet/extension-base/services/base/types';
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
 import { EventService } from '@subwallet/extension-base/services/event-service';
 import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
 import { BehaviorSubject } from 'rxjs';
-export declare class PriceService {
+export declare class PriceService implements StoppableServiceInterface, PersistDataServiceInterface, CronServiceInterface {
+    status: ServiceStatus;
     private dbService;
     private eventService;
     private chainService;
@@ -15,4 +17,23 @@ export declare class PriceService {
     getPriceSubject(): BehaviorSubject<PriceJson>;
     getPriceIds(): Set<string>;
     refreshPriceData(priceIds?: Set<string>): void;
+    init(): Promise<void>;
+    loadData(): Promise<void>;
+    persistData(): Promise<void>;
+    startPromiseHandler: {
+        resolve: (value: void) => void;
+        reject: (reason?: unknown) => void;
+        promise: Promise<void>;
+    };
+    start(): Promise<void>;
+    startCron(): Promise<void>;
+    stopPromiseHandler: {
+        resolve: (value: void) => void;
+        reject: (reason?: unknown) => void;
+        promise: Promise<void>;
+    };
+    stop(): Promise<void>;
+    stopCron(): Promise<void>;
+    waitForStarted(): Promise<void>;
+    waitForStopped(): Promise<void>;
 }

package/services/price-service/index.js

@@ -2,7 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { CRON_REFRESH_PRICE_INTERVAL } from '@subwallet/extension-base/constants';
+import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
 import { getTokenPrice } from '@subwallet/extension-base/services/price-service/coingecko';
+import { createPromiseHandler } from '@subwallet/extension-base/utils/promise';
 import { BehaviorSubject } from 'rxjs';
 const DEFAULT_PRICE_SUBJECT = {
   ready: false,
@@ -14,34 +16,14 @@ export class PriceService {
   priceSubject = new BehaviorSubject(DEFAULT_PRICE_SUBJECT);
   priceIds = new Set();
   constructor(dbService, eventService, chainService) {
+    this.status = ServiceStatus.NOT_INITIALIZED;
     this.dbService = dbService;
     this.eventService = eventService;
     this.chainService = chainService;
-
-    // Fetch data from storage
-    this.getPrice().catch(console.error);
-    const eventHandler = () => {
-      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);
-      }
-    };
-    this.eventService.waitAssetReady.then(() => {
-      this.refreshPriceData();
-      this.eventService.on('asset.updateState', eventHandler);
-      this.eventService.on('asset.updateState', eventHandler);
-    }).catch(console.error);
+    this.init().catch(console.error);
   }
   async getPrice() {
-    const isReady = this.priceSubject.value.ready;
-    if (!isReady) {
-      const data = await this.dbService.getPriceStore();
-      this.priceSubject.next(data || DEFAULT_PRICE_SUBJECT);
-    }
-    return this.priceSubject.value;
+    return Promise.resolve(this.priceSubject.value);
   }
   getPriceSubject() {
     return this.priceSubject;
@@ -65,4 +47,70 @@ export class PriceService {
     }).catch(console.error);
     this.refreshTimeout = setTimeout(this.refreshPriceData.bind(this), CRON_REFRESH_PRICE_INTERVAL);
   }
+  async init() {
+    this.status = ServiceStatus.INITIALIZING;
+    // Fetch data from storage
+    await this.loadData();
+    const eventHandler = () => {
+      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);
+      }
+    };
+    await this.eventService.waitAssetReady;
+    this.status = ServiceStatus.INITIALIZED;
+    this.eventService.on('asset.updateState', eventHandler);
+    this.eventService.on('asset.updateState', eventHandler);
+  }
+  async loadData() {
+    const data = await this.dbService.getPriceStore();
+    this.priceSubject.next(data || DEFAULT_PRICE_SUBJECT);
+  }
+  async persistData() {
+    await this.dbService.updatePriceStore(this.priceSubject.value).catch(console.error);
+  }
+  startPromiseHandler = createPromiseHandler();
+  async start() {
+    console.debug('Start price service');
+    try {
+      this.startPromiseHandler = createPromiseHandler();
+      this.status = ServiceStatus.STARTING;
+      await this.startCron();
+      this.status = ServiceStatus.STARTED;
+      this.startPromiseHandler.resolve();
+    } catch (e) {
+      this.startPromiseHandler.reject(e);
+    }
+  }
+  async startCron() {
+    this.refreshPriceData();
+    return Promise.resolve();
+  }
+  stopPromiseHandler = createPromiseHandler();
+  async stop() {
+    console.debug('Stop price service');
+    try {
+      this.status = ServiceStatus.STOPPING;
+      this.stopPromiseHandler = createPromiseHandler();
+      await this.stopCron();
+      await this.persistData();
+      this.status = ServiceStatus.STOPPED;
+      this.stopPromiseHandler.resolve();
+    } catch (e) {
+      this.stopPromiseHandler.reject(e);
+    }
+  }
+  stopCron() {
+    clearTimeout(this.refreshTimeout);
+    return Promise.resolve(undefined);
+  }
+  waitForStarted() {
+    return this.startPromiseHandler.promise;
+  }
+  waitForStopped() {
+    return this.stopPromiseHandler.promise;
+  }
 }

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

@@ -41,6 +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>;
     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

@@ -126,6 +126,16 @@ 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) {
+    // this.logger.log('Updating transaction histories');
+    const canUpdate = updateData && extrinsicHash;
+    if (!canUpdate) {
+      return;
+    }
+    return this.stores.transaction.updateWithQuery({
+      extrinsicHash
+    }, updateData);
+  }
 
   // NFT Collection
   async addNftCollection(collection) {

package/services/storage-service/db-stores/Transaction.d.ts

@@ -4,9 +4,11 @@ export interface HistoryQuery {
     chain?: string;
     address?: string;
     extrinsicHash?: string;
+    transactionId?: string;
 }
 export default class TransactionStore extends BaseStoreWithAddressAndChain<ITransactionHistoryItem> {
     getHistoryByAddressAsObject(address: string): Promise<ITransactionHistoryItem[]>;
     queryHistory(query?: HistoryQuery): Promise<ITransactionHistoryItem[]>;
     bulkUpsert(records: ITransactionHistoryItem[]): Promise<unknown>;
+    updateWithQuery(query: HistoryQuery, update: Partial<ITransactionHistoryItem>): Promise<unknown>;
 }

package/services/storage-service/db-stores/Transaction.js

@@ -29,16 +29,12 @@ export default class TransactionStore extends BaseStoreWithAddressAndChain {
   }
   async bulkUpsert(records) {
     await this.table.bulkPut(records);
-
-    // await Promise.all(records.map((record) => {
-    //   return this.table.where({
-    //     chain: record.chain,
-    //     address: record.address,
-    //     extrinsicHash: record.extrinsicHash
-    //   }).filter((item) => (item.origin === 'app' && record.origin !== 'app'))
-    //     .delete();
-    // }));
-
+    return true;
+  }
+  async updateWithQuery(query, update) {
+    await this.table.where(query).modify(record => {
+      return Object.assign(record, update);
+    });
     return true;
   }
 }

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

@@ -36,6 +36,8 @@ export default class TransactionService {
     private updateTransaction;
     private getTransactionLink;
     private transactionToHistories;
+    private onSigned;
+    private onSend;
     private onHasTransactionHash;
     private handlePostProcessing;
     private onSuccess;

package/services/transaction-service/index.js

@@ -37,7 +37,7 @@ export default class TransactionService {
     return Object.values(this.transactions);
   }
   get processingTransactions() {
-    return this.allTransactions.filter(t => t.status === ExtrinsicStatus.PENDING || t.status === ExtrinsicStatus.PROCESSING);
+    return this.allTransactions.filter(t => t.status === ExtrinsicStatus.QUEUED || t.status === ExtrinsicStatus.PROCESSING);
   }
   getTransaction(id) {
     return this.transactions[id];
@@ -157,6 +157,7 @@ export default class TransactionService {
   }
   fillTransactionDefaultInfo(transaction) {
     const isInternal = !transaction.url;
+    const transactionId = getTransactionId(transaction.chainType, transaction.chain, isInternal);
     return {
       ...transaction,
       createdAt: new Date(),
@@ -164,10 +165,10 @@ export default class TransactionService {
       errors: transaction.errors || [],
       warnings: transaction.warnings || [],
       url: transaction.url || EXTENSION_REQUEST_URL,
-      status: ExtrinsicStatus.PENDING,
+      status: ExtrinsicStatus.QUEUED,
       isInternal,
-      id: getTransactionId(transaction.chainType, transaction.chain, isInternal),
-      extrinsicHash: ''
+      id: transactionId,
+      extrinsicHash: transactionId
     };
   }
   async addTransaction(inputTransaction) {
@@ -180,8 +181,6 @@ export default class TransactionService {
     this.transactionSubject.next({
       ...transactions
     });
-
-    // Send transaction
     return await this.sendTransaction(transaction);
   }
   generateBeforeHandleResponseErrors(errors) {
@@ -208,7 +207,8 @@ export default class TransactionService {
     validatedTransaction.warnings = [];
     const emitter = await this.addTransaction(validatedTransaction);
     await new Promise(resolve => {
-      emitter.on('extrinsicHash', data => {
+      emitter.on('signed', data => {
+        validatedTransaction.id = data.id;
         validatedTransaction.extrinsicHash = data.extrinsicHash;
         resolve();
       });
@@ -224,6 +224,12 @@ export default class TransactionService {
   async sendTransaction(transaction) {
     // Send Transaction
     const emitter = transaction.chainType === 'substrate' ? this.signAndSendSubstrateTransaction(transaction) : await this.signAndSendEvmTransaction(transaction);
+    emitter.on('signed', data => {
+      this.onSigned(data);
+    });
+    emitter.on('send', data => {
+      this.onSend(data);
+    });
     emitter.on('extrinsicHash', data => {
       this.onHasTransactionHash(data);
     });
@@ -276,7 +282,8 @@ export default class TransactionService {
       to: '',
       chainType: transaction.chainType,
       address: transaction.address,
-      status: ExtrinsicStatus.PROCESSING,
+      status: transaction.status,
+      transactionId: transaction.id,
       extrinsicHash: transaction.extrinsicHash,
       time: transaction.createdAt.getTime(),
       fee: transaction.estimateFee,
@@ -419,8 +426,14 @@ export default class TransactionService {
           break;
         }
       case ExtrinsicType.EVM_EXECUTE:
-        // Todo: Update historyItem.to
-        break;
+        {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          const data = parseTransactionData(transaction.data);
+
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access
+          historyItem.to = (data === null || data === void 0 ? void 0 : data.to) || '';
+          break;
+        }
       case ExtrinsicType.UNKNOWN:
         break;
     }
@@ -439,17 +452,36 @@ export default class TransactionService {
     }
     return [historyItem];
   }
+  onSigned({
+    id
+  }) {
+    console.log(`Transaction "${id}" is signed`);
+  }
+  onSend({
+    id
+  }) {
+    // Update transaction status
+    this.updateTransaction(id, {
+      status: ExtrinsicStatus.SUBMITTING
+    });
+
+    // Create Input History Transaction History
+    this.historyService.insertHistories(this.transactionToHistories(id)).catch(console.error);
+    console.log(`Transaction "${id}" is sent`);
+  }
   onHasTransactionHash({
-    eventLogs,
     extrinsicHash,
     id
   }) {
     // Write processing transaction history
-    this.updateTransaction(id, {
+    const updateData = {
       extrinsicHash,
       status: ExtrinsicStatus.PROCESSING
-    });
-    this.historyService.insertHistories(this.transactionToHistories(id, eventLogs)).catch(console.error);
+    };
+    this.updateTransaction(id, updateData);
+
+    // In this case transaction id is the same as extrinsic hash and will change after below update
+    this.historyService.updateHistoryByExtrinsicHash(id, updateData).catch(console.error);
     console.log(`Transaction "${id}" is submitted with hash ${extrinsicHash || ''}`);
   }
   handlePostProcessing(id) {
@@ -513,16 +545,17 @@ export default class TransactionService {
     id
   }) {
     const transaction = this.getTransaction(id);
+    const nextStatus = ExtrinsicStatus.FAIL;
     if (transaction) {
       this.updateTransaction(id, {
-        status: ExtrinsicStatus.FAIL,
+        status: nextStatus,
         errors
       });
       console.log('Transaction failed', id, transaction.extrinsicHash);
 
       // Write failed transaction history
       this.historyService.updateHistories(transaction.chain, transaction.extrinsicHash, {
-        status: ExtrinsicStatus.FAIL,
+        status: nextStatus,
         blockNumber: blockNumber || 0,
         blockHash: blockHash || ''
       }).catch(console.error);
@@ -642,6 +675,12 @@ export default class TransactionService {
           }
           signedTransaction = signed;
         }
+
+        // Emit signed event
+        emitter.emit('signed', eventData);
+
+        // Send transaction
+        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);
@@ -680,7 +719,6 @@ export default class TransactionService {
       errors: [],
       warnings: []
     };
-    console.debug(address, transaction);
     transaction.signAsync(address, {
       signer: {
         signPayload: async payload => {
@@ -692,6 +730,11 @@ export default class TransactionService {
         }
       }
     }).then(rs => {
+      // Emit signed event
+      emitter.emit('signed', eventData);
+
+      // Send transaction
+      emitter.emit('send', eventData); // This event is needed after sending transaction with queue
       rs.send(txState => {
         // handle events, logs, history
         if (!txState || !txState.status) {

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

@@ -41,6 +41,8 @@ export interface TransactionEventResponse extends ValidateTransactionResponse {
     eventLogs?: EventRecord[];
 }
 export interface TransactionEventMap {
+    send: (response: TransactionEventResponse) => void;
+    signed: (response: TransactionEventResponse) => void;
     extrinsicHash: (response: TransactionEventResponse) => void;
     error: (response: TransactionEventResponse) => void;
     success: (response: TransactionEventResponse) => void;

package/services/transaction-service/utils.js

@@ -9,15 +9,17 @@ export function parseTransactionData(data) {
   return data;
 }
 export function getTransactionLink(chainInfo, extrinsicHash) {
-  const explorerLink = _getBlockExplorerFromChain(chainInfo);
-  if (_isPureEvmChain(chainInfo)) {
-    if (explorerLink) {
-      return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}tx/${extrinsicHash}`;
-    }
-  } else {
+  if (extrinsicHash.startsWith('0x')) {
     const explorerLink = _getBlockExplorerFromChain(chainInfo);
-    if (explorerLink) {
-      return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}extrinsic/${extrinsicHash}`;
+    if (_isPureEvmChain(chainInfo)) {
+      if (explorerLink) {
+        return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}tx/${extrinsicHash}`;
+      }
+    } else {
+      const explorerLink = _getBlockExplorerFromChain(chainInfo);
+      if (explorerLink) {
+        return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}extrinsic/${extrinsicHash}`;
+      }
     }
   }
   return undefined;

package/utils/promise.d.ts

@@ -0,0 +1,6 @@
+export declare function createPromiseHandler<T>(): {
+    resolve: (value: T) => void;
+    reject: (reason?: unknown) => void;
+    promise: Promise<T>;
+};
+export declare type PromiseHandler<T> = ReturnType<typeof createPromiseHandler<T>>;