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

package/services/storage-service/DatabaseService.js

@@ -6,6 +6,7 @@ import KoniDatabase from '@subwallet/extension-base/services/storage-service/dat
 import { AssetStore, BalanceStore, ChainStore, CrowdloanStore, MigrationStore, NftCollectionStore, NftStore, PriceStore, StakingStore, TransactionStore } from '@subwallet/extension-base/services/storage-service/db-stores';
 import ChainStakingMetadataStore from '@subwallet/extension-base/services/storage-service/db-stores/ChainStakingMetadata';
 import NominatorMetadataStore from '@subwallet/extension-base/services/storage-service/db-stores/NominatorMetadata';
+import { reformatAddress } from '@subwallet/extension-base/utils';
 import { logger as createLogger } from '@polkadot/util';
 export default class DatabaseService {
   // TODO: might remove this
@@ -47,7 +48,8 @@ export default class DatabaseService {
   }
   async updateBalanceStore(address, item) {
     if (item.state === APIItemState.READY) {
-      this.logger.log(`Updating balance for [${item.tokenSlug}]`);
+      // this.logger.log(`Updating balance for [${item.tokenSlug}]`);
+
       return this.stores.balance.upsert({
         address,
         ...item
@@ -62,14 +64,16 @@ export default class DatabaseService {
   // Crowdloan
   async updateCrowdloanStore(chain, address, item) {
     if (item.state === APIItemState.READY && item.contribute !== '0') {
-      this.logger.log(`Updating crowdloan for [${chain}]`);
+      // this.logger.log(`Updating crowdloan for [${chain}]`);
+
       return this.stores.crowdloan.upsert({
         chain,
         address,
         ...item
       });
     } else {
-      this.logger.debug(`Removing crowdloan for [${chain}]`);
+      // this.logger.debug(`Removing crowdloan for [${chain}]`);
+
       return this.stores.crowdloan.deleteByChainAndAddress(chain, address);
     }
   }
@@ -77,22 +81,23 @@ export default class DatabaseService {
   // Staking
   async updateStaking(chain, address, item) {
     if (item.state === APIItemState.READY) {
-      this.logger.log(`Updating staking for [${chain}]`);
+      // this.logger.log(`Updating staking for [${chain}]`);
+
       return this.stores.staking.upsert(item);
     }
   }
   async getStakings(addresses, chains) {
-    const stakings = await this.stores.staking.getStakings(addresses, chains);
-    this.logger.log('Get Stakings: ', stakings);
-    return stakings;
+    // this.logger.log('Get Stakings: ', stakings);
+
+    return this.stores.staking.getStakings(addresses, chains);
   }
   async getStakingsByChains(chains) {
     return this.stores.staking.getStakingsByChains(chains);
   }
   async getPooledStakings(addresses, chainHashes) {
-    const stakings = await this.stores.staking.getPooledStakings(addresses, chainHashes);
-    this.logger.log('Get Pooled Stakings: ', stakings);
-    return stakings;
+    // this.logger.log('Get Pooled Stakings: ', stakings);
+
+    return this.stores.staking.getPooledStakings(addresses, chainHashes);
   }
   subscribeStaking(addresses, chainList, callback) {
     this.stakingSubscription && this.stakingSubscription.unsubscribe();
@@ -114,18 +119,28 @@ export default class DatabaseService {
 
   // Transaction histories
   async getHistories(query) {
-    const histories = await this.stores.transaction.queryHistory(query);
-    this.logger.log('Get histories: ', histories);
-    return histories;
+    return this.stores.transaction.queryHistory(query);
   }
   async upsertHistory(histories) {
-    this.logger.log('Updating transaction histories');
-    return this.stores.transaction.bulkUpsert(histories);
+    // this.logger.log('Updating transaction histories');
+    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) {
-    this.logger.log(`Updating NFT collection for [${collection.chain}]`);
+    // this.logger.log(`Updating NFT collection for [${collection.chain}]`);
+
     return this.stores.nftCollection.upsert(collection);
   }
   async deleteNftCollection(chain, collectionId) {
@@ -144,13 +159,22 @@ export default class DatabaseService {
     });
     return this.nftSubscription;
   }
+  async cleanUpNft(chain, owner, collectionIds, nftIds, ownNothing) {
+    if (ownNothing) {
+      return this.stores.nft.deleteNftsByChainAndOwner(chain, reformatAddress(owner, 42));
+    }
+    const result = await this.stores.nft.cleanUpNfts(chain, reformatAddress(owner, 42), collectionIds, nftIds);
+    result > 0 && console.debug(`Cleaned up ${result} NFTs on chain ${chain} for owner ${reformatAddress(owner, 42)}`, collectionIds, nftIds);
+    return result;
+  }
   async getNft(addresses, chainHashes) {
-    const nfts = await this.stores.nft.getNft(addresses, chainHashes);
-    this.logger.log('Get NFTs: ', nfts);
-    return nfts;
+    // this.logger.log('Get NFTs: ', nfts);
+
+    return this.stores.nft.getNft(addresses, chainHashes);
   }
   async addNft(address, nft) {
-    this.logger.log(`Updating NFT for [${nft.chain}]`);
+    // this.logger.log(`Updating NFT for [${nft.chain}]`);
+
     return this.stores.nft.upsert({
       ...nft,
       address
@@ -160,47 +184,54 @@ export default class DatabaseService {
     return this.stores.nft.deleteNftItem(chain, addresses, nftItem);
   }
   removeNfts(chain, address, collectionId, nftIds) {
-    this.logger.log(`Remove NFTs [${nftIds.join(', ')}]`);
+    // this.logger.log(`Remove NFTs [${nftIds.join(', ')}]`);
+
     return this.stores.nft.removeNfts(chain, address, collectionId, nftIds);
   }
 
   // Chain
   async updateChainStore(item) {
-    this.logger.log(`Updating storageInfo for chain [${item.slug}]`);
+    // this.logger.log(`Updating storageInfo for chain [${item.slug}]`);
+
     return this.stores.chain.upsert(item);
   }
   async bulkUpdateChainStore(data) {
-    this.logger.log('Bulk updating ChainStore');
+    // this.logger.log('Bulk updating ChainStore');
+
     return this.stores.chain.bulkUpsert(data);
   }
   async removeFromChainStore(chains) {
-    this.logger.log('Bulk removing ChainStore');
+    // this.logger.log('Bulk removing ChainStore');
+
     return this.stores.chain.removeChains(chains);
   }
   async getAllChainStore() {
-    const allChains = await this.stores.chain.getAll();
-    this.logger.log('Get all chains: ', allChains);
-    return allChains;
+    // this.logger.log('Get all chains: ', allChains);
+
+    return this.stores.chain.getAll();
   }
 
   // Asset
   async updateAssetStore(item) {
-    this.logger.log(`Updating storageInfo for chainAsset [${item.originChain}]`);
+    // this.logger.log(`Updating storageInfo for chainAsset [${item.originChain}]`);
+
     return this.stores.asset.upsert(item);
   }
   async getAllAssetStore() {
-    const allAssets = await this.stores.asset.getAll();
-    this.logger.log('Get all stored assets: ', allAssets);
-    return allAssets;
+    // this.logger.log('Get all stored assets: ', allAssets);
+
+    return this.stores.asset.getAll();
   }
   async removeFromAssetStore(items) {
-    this.logger.log('Bulk removing AssetStore');
+    // this.logger.log('Bulk removing AssetStore');
+
     return this.stores.asset.removeAssets(items);
   }
 
   // Staking
   async updateChainStakingMetadata(item) {
-    this.logger.log('Update ChainStakingMetadata: ', item.chain);
+    // this.logger.log('Update ChainStakingMetadata: ', item.chain);
+
     return this.stores.chainStakingMetadata.upsert(item);
   }
   async getChainStakingMetadata() {
@@ -210,7 +241,8 @@ export default class DatabaseService {
     return this.stores.chainStakingMetadata.getByChainAndType(chain, type);
   }
   async updateNominatorMetadata(item) {
-    this.logger.log('Update NominatorMetadata: ', item.address, item.chain);
+    // this.logger.log('Update NominatorMetadata: ', item.address, item.chain);
+
     return this.stores.nominatorMetadata.upsert(item);
   }
   async getNominatorMetadata() {

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

@@ -4,8 +4,8 @@ import { INft } from '../databases';
 export default class NftStore extends BaseStoreWithAddressAndChain<INft> {
     getNft(addresses: string[], chainList?: string[]): import("dexie").PromiseExtended<INft[]>;
     subscribeNft(addresses: string[], chainList?: string[]): import("dexie").Observable<INft[]>;
-    deleteRemovedNftsFromCollection(chainHash: string, address: string, collection?: string, nftIds?: string[]): void | import("dexie").PromiseExtended<number>;
-    deleteNftsFromRemovedCollection(chain: string, address: string, collectionIds: string[]): import("dexie").Collection<INft, unknown>;
+    cleanUpNfts(chain: string, address: string, collectionIds: string[], nftIds: string[]): import("dexie").PromiseExtended<number>;
+    deleteNftsByChainAndOwner(chain: string, address: string): import("dexie").PromiseExtended<number>;
     deleteNftByAddress(addresses: string[]): import("dexie").PromiseExtended<number>;
     deleteNftItem(chain: string, addresses: string[], nftItem: NftItem): import("dexie").PromiseExtended<number>;
     deleteNftsByCollection(chain: string, collectionId: string): import("dexie").PromiseExtended<number>;

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

@@ -15,24 +15,17 @@ export default class NftStore extends BaseStoreWithAddressAndChain {
   subscribeNft(addresses, chainList = []) {
     return liveQuery(() => this.getNft(addresses, chainList));
   }
-  deleteRemovedNftsFromCollection(chainHash, address, collection, nftIds = []) {
-    const conditions = {
-      chainHash,
-      address
-    };
-    if (!collection && nftIds && nftIds.length) {
-      return this.logger.warn('Missing collection id');
-    }
-    if (collection) {
-      conditions.collectionId = collection;
-    }
-    return this.table.where(conditions).and(item => !nftIds.some(nft => nft === item.id)).delete();
+  cleanUpNfts(chain, address, collectionIds, nftIds) {
+    return this.table.where({
+      address,
+      chain
+    }).and(nft => !collectionIds.includes(nft.collectionId) || collectionIds.includes(nft.collectionId) && !nftIds.includes(nft.id)).delete();
   }
-  deleteNftsFromRemovedCollection(chain, address, collectionIds) {
+  deleteNftsByChainAndOwner(chain, address) {
     return this.table.where({
       address,
       chain
-    }).and(nft => !collectionIds.some(item => item === nft.collectionId));
+    }).delete();
   }
   deleteNftByAddress(addresses) {
     return this.table.where('address').anyOfIgnoreCase(addresses).delete();

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/event-parser/index.js

@@ -1,45 +1,30 @@
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { _getAssetDecimals, _getChainNativeTokenBasicInfo, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getAssetDecimals, _getChainNativeTokenBasicInfo } from '@subwallet/extension-base/services/chain-service/utils';
 export function parseXcmEventLogs(historyItem, eventLogs, chain, sendingTokenInfo, chainInfo) {
-  let isFeeUseMainTokenSymbol = true;
   for (let index = 0; index < eventLogs.length; index++) {
     const record = eventLogs[index];
-    if (['karura', 'acala', 'acala_testnet'].includes(chain) && sendingTokenInfo && !_isNativeToken(sendingTokenInfo)) {
-      if (record.event.section === 'currencies' && record.event.method.toLowerCase() === 'transferred') {
-        if (index === 0) {
-          var _record$event$data$;
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-          historyItem.fee = {
-            value: ((_record$event$data$ = record.event.data[3]) === null || _record$event$data$ === void 0 ? void 0 : _record$event$data$.toString()) || '0',
-            symbol: sendingTokenInfo.symbol,
-            decimals: _getAssetDecimals(sendingTokenInfo)
-          };
-          isFeeUseMainTokenSymbol = false;
-        }
-      }
-    }
     const {
       decimals: nativeDecimals,
       symbol: nativeSymbol
     } = _getChainNativeTokenBasicInfo(chainInfo);
-    if (isFeeUseMainTokenSymbol && record.event.section === 'balances' && record.event.method.toLowerCase() === 'withdraw') {
-      var _record$event$data$2;
-      if ((_record$event$data$2 = record.event.data[1]) !== null && _record$event$data$2 !== void 0 && _record$event$data$2.toString()) {
-        var _record$event$data$3;
+    if (record.event.section === 'balances' && record.event.method.toLowerCase() === 'withdraw') {
+      var _record$event$data$;
+      if ((_record$event$data$ = record.event.data[1]) !== null && _record$event$data$ !== void 0 && _record$event$data$.toString()) {
+        var _record$event$data$2;
         historyItem.fee = {
-          value: (_record$event$data$3 = record.event.data[1]) === null || _record$event$data$3 === void 0 ? void 0 : _record$event$data$3.toString(),
+          value: (_record$event$data$2 = record.event.data[1]) === null || _record$event$data$2 === void 0 ? void 0 : _record$event$data$2.toString(),
           symbol: nativeSymbol,
           decimals: nativeDecimals
         };
       }
-    } else if (isFeeUseMainTokenSymbol && record.event.section === 'tokens' && record.event.method.toLowerCase() === 'withdrawn') {
-      var _record$event$data$4;
-      if ((_record$event$data$4 = record.event.data[2]) !== null && _record$event$data$4 !== void 0 && _record$event$data$4.toString()) {
-        var _record$event$data$5;
+    } else if (record.event.section === 'tokens' && record.event.method.toLowerCase() === 'withdrawn') {
+      var _record$event$data$3;
+      if (!historyItem.fee && (_record$event$data$3 = record.event.data[2]) !== null && _record$event$data$3 !== void 0 && _record$event$data$3.toString()) {
+        var _record$event$data$4;
         historyItem.fee = {
-          value: (_record$event$data$5 = record.event.data[2]) === null || _record$event$data$5 === void 0 ? void 0 : _record$event$data$5.toString(),
+          value: (_record$event$data$4 = record.event.data[2]) === null || _record$event$data$4 === void 0 ? void 0 : _record$event$data$4.toString(),
           symbol: nativeSymbol,
           decimals: nativeDecimals
         };
@@ -48,28 +33,15 @@ export function parseXcmEventLogs(historyItem, eventLogs, chain, sendingTokenInf
   }
 }
 export function parseTransferEventLogs(historyItem, eventLogs, chain, sendingTokenInfo, chainInfo) {
-  let isFeeUseMainTokenSymbol = true;
   for (let index = 0; index < eventLogs.length; index++) {
     const record = eventLogs[index];
-    if (['karura', 'acala', 'acala_testnet'].includes(chain) && !_isNativeToken(sendingTokenInfo)) {
-      if (record.event.section === 'currencies' && record.event.method.toLowerCase() === 'transferred') {
-        if (index === 0) {
-          var _record$event$data$6;
-          historyItem.fee = {
-            value: ((_record$event$data$6 = record.event.data[3]) === null || _record$event$data$6 === void 0 ? void 0 : _record$event$data$6.toString()) || '0',
-            symbol: sendingTokenInfo.symbol,
-            decimals: _getAssetDecimals(sendingTokenInfo)
-          };
-          isFeeUseMainTokenSymbol = false;
-        }
-      }
-    } else if (['genshiro_testnet', 'genshiro', 'equilibrium_parachain'].includes(chain) && sendingTokenInfo) {
+    if (['genshiro_testnet', 'genshiro', 'equilibrium_parachain'].includes(chain) && sendingTokenInfo) {
       if (record.event.section === 'transactionPayment' && record.event.method.toLowerCase() === 'transactionfeepaid') {
-        var _record$event$data$7;
-        if ((_record$event$data$7 = record.event.data[1]) !== null && _record$event$data$7 !== void 0 && _record$event$data$7.toString()) {
-          var _record$event$data$8;
+        var _record$event$data$5;
+        if ((_record$event$data$5 = record.event.data[1]) !== null && _record$event$data$5 !== void 0 && _record$event$data$5.toString()) {
+          var _record$event$data$6;
           historyItem.fee = {
-            value: ((_record$event$data$8 = record.event.data[1]) === null || _record$event$data$8 === void 0 ? void 0 : _record$event$data$8.toString()) || '0',
+            value: ((_record$event$data$6 = record.event.data[1]) === null || _record$event$data$6 === void 0 ? void 0 : _record$event$data$6.toString()) || '0',
             symbol: sendingTokenInfo.symbol,
             decimals: _getAssetDecimals(sendingTokenInfo)
           };
@@ -80,13 +52,13 @@ export function parseTransferEventLogs(historyItem, eventLogs, chain, sendingTok
       decimals: nativeDecimals,
       symbol: nativeSymbol
     } = _getChainNativeTokenBasicInfo(chainInfo);
-    if (isFeeUseMainTokenSymbol && record.event.section === 'balances' && record.event.method.toLowerCase() === 'withdraw') {
-      var _record$event$data$9;
-      if ((_record$event$data$9 = record.event.data[1]) !== null && _record$event$data$9 !== void 0 && _record$event$data$9.toString()) {
-        var _record$event$data$10;
+    if (record.event.section === 'balances' && record.event.method.toLowerCase() === 'withdraw') {
+      var _record$event$data$7;
+      if ((_record$event$data$7 = record.event.data[1]) !== null && _record$event$data$7 !== void 0 && _record$event$data$7.toString()) {
+        var _record$event$data$8;
         // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
         historyItem.fee = {
-          value: ((_record$event$data$10 = record.event.data[1]) === null || _record$event$data$10 === void 0 ? void 0 : _record$event$data$10.toString()) || '0',
+          value: ((_record$event$data$8 = record.event.data[1]) === null || _record$event$data$8 === void 0 ? void 0 : _record$event$data$8.toString()) || '0',
           symbol: nativeSymbol,
           decimals: nativeDecimals
         };

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,9 +181,6 @@ export default class TransactionService {
     this.transactionSubject.next({
       ...transactions
     });
-    console.log(transaction);
-
-    // Send transaction
     return await this.sendTransaction(transaction);
   }
   generateBeforeHandleResponseErrors(errors) {
@@ -209,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();
       });
@@ -225,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);
     });
@@ -277,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,
@@ -420,18 +426,24 @@ 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;
     }
     try {
       // Return one more history record if transaction send to account in the wallets
-      const toAccount = (historyItem === null || historyItem === void 0 ? void 0 : historyItem.to) && keyring.getAccount(historyItem.to);
+      const toAccount = (historyItem === null || historyItem === void 0 ? void 0 : historyItem.to) && keyring.getPair(historyItem.to);
       if (toAccount) {
         return [historyItem, {
           ...historyItem,
-          address: historyItem.to,
+          address: toAccount.address,
           direction: TransactionDirection.RECEIVED
         }];
       }
@@ -440,34 +452,62 @@ 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) {
     // must be done after success/failure to make sure the transaction is finalized
     const transaction = this.getTransaction(id);
-    switch (transaction.extrinsicType) {
-      case ExtrinsicType.SEND_NFT:
-        {
-          const inputData = parseTransactionData(transaction.data);
-          const sender = keyring.getAccount(inputData.senderAddress);
-          const recipient = keyring.getAccount(inputData.recipientAddress);
-          sender && this.databaseService.handleNftTransfer(transaction.chain, [sender.address, ALL_ACCOUNT_KEY], inputData.nftItem).catch(console.error);
-          recipient && this.databaseService.addNft(recipient.address, {
-            ...inputData.nftItem,
-            owner: recipient.address
-          }).catch(console.error);
-        }
+    if (transaction.extrinsicType === ExtrinsicType.SEND_NFT) {
+      const inputData = parseTransactionData(transaction.data);
+      try {
+        const sender = keyring.getPair(inputData.senderAddress);
+        sender && this.databaseService.handleNftTransfer(transaction.chain, [sender.address, ALL_ACCOUNT_KEY], inputData.nftItem).then(() => {
+          this.eventService.emit('transaction.transferNft', undefined);
+        }).catch(console.error);
+      } catch (e) {
+        console.error(e);
+      }
+      try {
+        const recipient = keyring.getPair(inputData.recipientAddress);
+        recipient && this.databaseService.addNft(recipient.address, {
+          ...inputData.nftItem,
+          owner: recipient.address
+        }).catch(console.error);
+      } catch (e) {
+        console.error(e);
+      }
+    } else if ([ExtrinsicType.STAKING_BOND, ExtrinsicType.STAKING_UNBOND, ExtrinsicType.STAKING_WITHDRAW, ExtrinsicType.STAKING_CANCEL_UNSTAKE, ExtrinsicType.STAKING_CLAIM_REWARD, ExtrinsicType.STAKING_JOIN_POOL, ExtrinsicType.STAKING_POOL_WITHDRAW, ExtrinsicType.STAKING_LEAVE_POOL].includes(transaction.extrinsicType)) {
+      this.eventService.emit('transaction.submitStaking', transaction.chain);
     }
   }
   onSuccess({
@@ -505,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);
@@ -576,6 +617,9 @@ export default class TransactionService {
       payload.isToContract = isToContract;
       payload.parseData = isToContract ? payload.data ? (await parseContractInput(payload.data || '', payload.to || '', chainInfo)).result : '' : payload.data || '';
     }
+    if ('data' in payload && payload.data === undefined) {
+      delete payload.data;
+    }
 
     // Set unique nonce to avoid transaction errors
     if (!payload.nonce) {
@@ -631,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);
@@ -669,7 +719,6 @@ export default class TransactionService {
       errors: [],
       warnings: []
     };
-    console.debug(address, transaction);
     transaction.signAsync(address, {
       signer: {
         signPayload: async payload => {
@@ -681,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;