@subwallet/extension-base 1.1.33-0 → 1.1.33-beta.1

package/services/transaction-service/index.js

@@ -6,14 +6,14 @@ import { TransactionError } from '@subwallet/extension-base/background/errors/Tr
 import { BasicTxErrorType, BasicTxWarningCode, ChainType, EvmProviderErrorType, ExtrinsicStatus, ExtrinsicType, NotificationType, TransactionDirection } from '@subwallet/extension-base/background/KoniTypes';
 import { TransactionWarning } from '@subwallet/extension-base/background/warnings/TransactionWarning';
 import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
-import { _TRANSFER_CHAIN_GROUP } from '@subwallet/extension-base/services/chain-service/constants';
-import { _getChainNativeTokenBasicInfo, _getEvmChainId } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getAssetDecimals, _getAssetSymbol, _getChainNativeTokenBasicInfo, _getEvmChainId, _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
 import { EXTENSION_REQUEST_URL } from '@subwallet/extension-base/services/request-service/constants';
 import { TRANSACTION_TIMEOUT } from '@subwallet/extension-base/services/transaction-service/constants';
-import { parseTransferEventLogs, parseXcmEventLogs } from '@subwallet/extension-base/services/transaction-service/event-parser';
+import { parseLiquidStakingEvents, parseLiquidStakingFastUnstakeEvents, parseTransferEventLogs, parseXcmEventLogs } from '@subwallet/extension-base/services/transaction-service/event-parser';
 import { getBaseTransactionInfo, getTransactionId, isSubstrateTransaction } from '@subwallet/extension-base/services/transaction-service/helpers';
 import { getExplorerLink, parseTransactionData } from '@subwallet/extension-base/services/transaction-service/utils';
 import { isWalletConnectRequest } from '@subwallet/extension-base/services/wallet-connect-service/helpers';
+import { YieldPoolType } from '@subwallet/extension-base/types';
 import { reformatAddress } from '@subwallet/extension-base/utils';
 import { anyNumberToBN, recalculateGasPrice } from '@subwallet/extension-base/utils/eth';
 import { mergeTransactionAndSignature } from '@subwallet/extension-base/utils/eth/mergeTransactionAndSignature';
@@ -26,20 +26,19 @@ import EventEmitter from 'eventemitter3';
 import { t } from 'i18next';
 import { BehaviorSubject } from 'rxjs';
 import { isHex } from '@polkadot/util';
+import { _TRANSFER_CHAIN_GROUP } from "../chain-service/constants.js";
 export default class TransactionService {
   transactionSubject = new BehaviorSubject({});
   watchTransactionSubscribes = {};
   get transactions() {
     return this.transactionSubject.getValue();
   }
-  constructor(chainService, eventService, requestService, balanceService, historyService, notificationService, databaseService) {
-    this.chainService = chainService;
-    this.eventService = eventService;
-    this.requestService = requestService;
-    this.balanceService = balanceService;
-    this.historyService = historyService;
-    this.notificationService = notificationService;
-    this.databaseService = databaseService;
+  constructor(state) {
+    this.state = state;
+    this.eventService = state.eventService;
+    this.historyService = state.historyService;
+    this.notificationService = state.notificationService;
+    this.chainService = state.chainService;
   }
   get allTransactions() {
     return Object.values(this.transactions);
@@ -96,7 +95,7 @@ export default class TransactionService {
       decimals: 0,
       value: ''
     };
-    const chainInfo = this.chainService.getChainInfoByKey(chain);
+    const chainInfo = this.state.chainService.getChainInfoByKey(chain);
     if (!chainInfo) {
       validationResponse.errors.push(new TransactionError(BasicTxErrorType.INTERNAL_ERROR, t('Cannot find network')));
     } else {
@@ -111,7 +110,7 @@ export default class TransactionService {
           if (isSubstrateTransaction(transaction)) {
             estimateFee.value = (await transaction.paymentInfo(address)).partialFee.toString();
           } else {
-            const web3 = this.chainService.getEvmApi(chain);
+            const web3 = this.state.chainService.getEvmApi(chain);
             if (!web3) {
               validationResponse.errors.push(new TransactionError(BasicTxErrorType.CHAIN_DISCONNECTED, undefined));
             } else {
@@ -145,32 +144,35 @@ export default class TransactionService {
 
     // Balance
     const transferNative = validationResponse.transferNativeAmount || '0';
-    const nativeTokenInfo = this.chainService.getNativeTokenInfo(chain);
-    const balance = await this.balanceService.getTokenFreeBalance(address, chain, nativeTokenInfo.slug);
+    const nativeTokenInfo = this.state.chainService.getNativeTokenInfo(chain);
+    const balance = await this.state.balanceService.getTokenFreeBalance(address, chain, nativeTokenInfo.slug);
     const existentialDeposit = nativeTokenInfo.minAmount || '0';
     const feeNum = parseInt(estimateFee.value);
     const balanceNum = parseInt(balance.value);
     const edNum = parseInt(existentialDeposit);
     const transferNativeNum = parseInt(transferNative);
-    if (!new BigN(balance.value).gt(0)) {
-      validationResponse.errors.push(new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE));
-    }
-    if (transferNativeNum + feeNum > balanceNum) {
-      if (!isTransferAll) {
+    if (!validationInput.skipFeeValidation) {
+      // TODO
+      if (!new BigN(balance.value).gt(0)) {
         validationResponse.errors.push(new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE));
-      } else {
-        if ([..._TRANSFER_CHAIN_GROUP.acala, ..._TRANSFER_CHAIN_GROUP.genshiro, ..._TRANSFER_CHAIN_GROUP.bitcountry, ..._TRANSFER_CHAIN_GROUP.statemine].includes(chain)) {
-          // Chain not have transfer all function
+      }
+      if (transferNativeNum + feeNum > balanceNum) {
+        if (!isTransferAll) {
           validationResponse.errors.push(new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE));
+        } else {
+          if ([..._TRANSFER_CHAIN_GROUP.acala, ..._TRANSFER_CHAIN_GROUP.genshiro, ..._TRANSFER_CHAIN_GROUP.bitcountry, ..._TRANSFER_CHAIN_GROUP.statemine].includes(chain)) {
+            // Chain not have transfer all function
+            validationResponse.errors.push(new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE));
+          }
         }
       }
-    }
-    if (!isTransferAll) {
-      if (balanceNum - (transferNativeNum + feeNum) < edNum) {
-        if (edAsWarning) {
-          validationResponse.warnings.push(new TransactionWarning(BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT));
-        } else {
-          validationResponse.errors.push(new TransactionError(BasicTxErrorType.NOT_ENOUGH_EXISTENTIAL_DEPOSIT));
+      if (!isTransferAll) {
+        if (balanceNum - (transferNativeNum + feeNum) < edNum) {
+          if (edAsWarning) {
+            validationResponse.warnings.push(new TransactionWarning(BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT));
+          } else {
+            validationResponse.errors.push(new TransactionError(BasicTxErrorType.NOT_ENOUGH_EXISTENTIAL_DEPOSIT));
+          }
         }
       }
     }
@@ -237,12 +239,21 @@ export default class TransactionService {
     }
     validatedTransaction.warnings = [];
     const emitter = await this.addTransaction(validatedTransaction);
-    await new Promise(resolve => {
-      emitter.on('signed', data => {
-        validatedTransaction.id = data.id;
-        validatedTransaction.extrinsicHash = data.extrinsicHash;
-        resolve();
-      });
+    await new Promise((resolve, reject) => {
+      // TODO
+      if (transaction.resolveOnDone) {
+        emitter.on('success', data => {
+          validatedTransaction.id = data.id;
+          validatedTransaction.extrinsicHash = data.extrinsicHash;
+          resolve();
+        });
+      } else {
+        emitter.on('signed', data => {
+          validatedTransaction.id = data.id;
+          validatedTransaction.extrinsicHash = data.extrinsicHash;
+          resolve();
+        });
+      }
       emitter.on('error', data => {
         if (data.errors.length > 0) {
           validatedTransaction.errors.push(...data.errors);
@@ -314,7 +325,7 @@ export default class TransactionService {
   }
   getTransactionLink(id) {
     const transaction = this.getTransaction(id);
-    const chainInfo = this.chainService.getChainInfoByKey(transaction.chain);
+    const chainInfo = this.state.chainService.getChainInfoByKey(transaction.chain);
     return getExplorerLink(chainInfo, transaction.extrinsicHash, 'tx');
   }
   transactionToHistories(id, startBlock, nonce, eventLogs) {
@@ -342,7 +353,7 @@ export default class TransactionService {
       nonce: nonce !== null && nonce !== void 0 ? nonce : 0,
       startBlock: startBlock || 0
     };
-    const chainInfo = this.chainService.getChainInfoByKey(transaction.chain);
+    const chainInfo = this.state.chainService.getChainInfoByKey(transaction.chain);
     const nativeAsset = _getChainNativeTokenBasicInfo(chainInfo);
     const baseNativeAmount = {
       value: '0',
@@ -356,7 +367,7 @@ export default class TransactionService {
         {
           const inputData = parseTransactionData(transaction.data);
           historyItem.to = inputData.to;
-          const sendingTokenInfo = this.chainService.getAssetBySlug(inputData.tokenSlug);
+          const sendingTokenInfo = this.state.chainService.getAssetBySlug(inputData.tokenSlug);
           historyItem.amount = {
             value: inputData.value || '0',
             decimals: sendingTokenInfo.decimals || 0,
@@ -369,7 +380,7 @@ export default class TransactionService {
         {
           const inputData = parseTransactionData(transaction.data);
           historyItem.to = inputData.to;
-          const sendingTokenInfo = this.chainService.getAssetBySlug(inputData.tokenSlug);
+          const sendingTokenInfo = this.state.chainService.getAssetBySlug(inputData.tokenSlug);
           historyItem.amount = {
             value: inputData.value || '0',
             decimals: sendingTokenInfo.decimals || 0,
@@ -382,7 +393,7 @@ export default class TransactionService {
         {
           const inputData = parseTransactionData(transaction.data);
           historyItem.to = inputData.to;
-          const sendingTokenInfo = this.chainService.getAssetBySlug(inputData.tokenSlug);
+          const sendingTokenInfo = this.state.chainService.getAssetBySlug(inputData.tokenSlug);
           historyItem.amount = {
             value: inputData.value || '0',
             decimals: sendingTokenInfo.decimals || 0,
@@ -431,17 +442,29 @@ export default class TransactionService {
       case ExtrinsicType.STAKING_UNBOND:
         {
           const data = parseTransactionData(transaction.data);
-          historyItem.to = data.validatorAddress || '';
-          historyItem.amount = {
-            ...baseNativeAmount,
-            value: data.amount || '0'
-          };
+          if (data.isLiquidStaking && data.derivativeTokenInfo && data.exchangeRate && data.inputTokenInfo) {
+            historyItem.amount = {
+              decimals: _getAssetDecimals(data.derivativeTokenInfo),
+              symbol: _getAssetSymbol(data.derivativeTokenInfo),
+              value: data.amount
+            };
+            historyItem.additionalInfo = {
+              inputTokenSlug: data.inputTokenInfo.slug,
+              exchangeRate: data.exchangeRate
+            };
+          } else {
+            historyItem.to = data.validatorAddress || '';
+            historyItem.amount = {
+              ...baseNativeAmount,
+              value: data.amount || '0'
+            };
+          }
         }
         break;
       case ExtrinsicType.STAKING_LEAVE_POOL:
         {
           const data = parseTransactionData(transaction.data);
-          historyItem.to = data.nominatorMetadata.address || '';
+          historyItem.to = data.address || '';
           historyItem.amount = {
             ...baseNativeAmount,
             value: data.amount || '0'
@@ -460,11 +483,21 @@ export default class TransactionService {
       case ExtrinsicType.STAKING_WITHDRAW:
         {
           const data = parseTransactionData(transaction.data);
-          historyItem.to = data.validatorAddress || '';
-          historyItem.amount = {
+          const slug = data.slug;
+          const poolHandler = this.state.earningService.getPoolHandler(slug);
+          const amount = {
             ...baseNativeAmount,
             value: data.unstakingInfo.claimable || '0'
           };
+          if (poolHandler) {
+            const asset = this.state.getAssetBySlug(poolHandler.metadataInfo.inputAsset);
+            if (asset) {
+              amount.decimals = asset.decimals || 0;
+              amount.symbol = asset.symbol;
+            }
+          }
+          historyItem.to = data.unstakingInfo.validatorAddress || '';
+          historyItem.amount = amount;
           break;
         }
       case ExtrinsicType.STAKING_CANCEL_UNSTAKE:
@@ -485,6 +518,119 @@ export default class TransactionService {
           historyItem.to = (data === null || data === void 0 ? void 0 : data.to) || '';
           break;
         }
+      case ExtrinsicType.MINT_STDOT:
+      case ExtrinsicType.MINT_QDOT:
+      case ExtrinsicType.MINT_LDOT:
+      case ExtrinsicType.MINT_SDOT:
+      case ExtrinsicType.MINT_VMANTA:
+
+      // eslint-disable-next-line no-fallthrough
+      case ExtrinsicType.MINT_VDOT:
+        {
+          const params = parseTransactionData(transaction.data);
+          const inputTokenInfo = this.state.chainService.getAssetBySlug(params.inputTokenSlug);
+          const isFeePaidWithInputAsset = params.feeTokenSlug === params.inputTokenSlug;
+          historyItem.amount = {
+            value: params.amount,
+            symbol: _getAssetSymbol(inputTokenInfo),
+            decimals: _getAssetDecimals(inputTokenInfo)
+          };
+          const additionalInfo = {
+            slug: params.slug,
+            derivativeTokenSlug: params.derivativeTokenSlug,
+            exchangeRate: params.exchangeRate
+          };
+          historyItem.additionalInfo = additionalInfo;
+          eventLogs && !_isChainEvmCompatible(chainInfo) && parseLiquidStakingEvents(historyItem, eventLogs, inputTokenInfo, chainInfo, isFeePaidWithInputAsset, extrinsicType);
+          break;
+        }
+      case ExtrinsicType.UNSTAKE_QDOT:
+
+      // eslint-disable-next-line no-fallthrough
+      case ExtrinsicType.REDEEM_QDOT:
+        {
+          const data = parseTransactionData(transaction.data);
+          const yieldPoolInfo = data.poolInfo;
+          if (yieldPoolInfo.metadata.derivativeAssets) {
+            const inputTokenSlug = yieldPoolInfo.metadata.inputAsset;
+            const inputTokenInfo = this.state.chainService.getAssetBySlug(inputTokenSlug);
+            historyItem.amount = {
+              value: data.amount,
+              symbol: _getAssetSymbol(inputTokenInfo),
+              decimals: _getAssetDecimals(inputTokenInfo)
+            };
+            eventLogs && parseLiquidStakingFastUnstakeEvents(historyItem, eventLogs, chainInfo, extrinsicType);
+            const additionalInfo = {
+              minAmountPercent: 1,
+              symbol: inputTokenInfo.symbol,
+              decimals: inputTokenInfo.decimals || 0,
+              exchangeRate: 1,
+              slug: yieldPoolInfo.slug,
+              type: yieldPoolInfo.type,
+              chain: yieldPoolInfo.chain,
+              group: yieldPoolInfo.group,
+              isFast: data.fastLeave
+            };
+            historyItem.additionalInfo = additionalInfo;
+          }
+          break;
+        }
+      case ExtrinsicType.UNSTAKE_VDOT:
+      case ExtrinsicType.UNSTAKE_VMANTA:
+      case ExtrinsicType.UNSTAKE_LDOT:
+      case ExtrinsicType.UNSTAKE_SDOT:
+      case ExtrinsicType.UNSTAKE_STDOT:
+      case ExtrinsicType.REDEEM_STDOT:
+      case ExtrinsicType.REDEEM_LDOT:
+      case ExtrinsicType.REDEEM_SDOT:
+      case ExtrinsicType.REDEEM_VMANTA:
+
+      // eslint-disable-next-line no-fallthrough
+      case ExtrinsicType.REDEEM_VDOT:
+        {
+          const data = parseTransactionData(transaction.data);
+          const yieldPoolInfo = data.poolInfo;
+          const minAmountPercents = this.state.earningService.getMinAmountPercent();
+          if (yieldPoolInfo.metadata.derivativeAssets) {
+            var _yieldPoolInfo$statis;
+            const derivativeTokenSlug = yieldPoolInfo.metadata.derivativeAssets[0];
+            const derivativeTokenInfo = this.state.chainService.getAssetBySlug(derivativeTokenSlug);
+            const chainInfo = this.state.chainService.getChainInfoByKey(data.poolInfo.chain);
+            historyItem.amount = {
+              value: data.amount,
+              symbol: _getAssetSymbol(derivativeTokenInfo),
+              decimals: _getAssetDecimals(derivativeTokenInfo)
+            };
+            eventLogs && !_isChainEvmCompatible(chainInfo) && parseLiquidStakingFastUnstakeEvents(historyItem, eventLogs, chainInfo, extrinsicType);
+            const minAmountPercent = minAmountPercents[yieldPoolInfo.slug] || 1;
+            const inputTokenSlug = yieldPoolInfo.metadata.inputAsset;
+            const inputTokenInfo = this.state.chainService.getAssetBySlug(inputTokenSlug);
+            const additionalInfo = {
+              minAmountPercent,
+              symbol: inputTokenInfo.symbol,
+              decimals: inputTokenInfo.decimals || 0,
+              exchangeRate: ((_yieldPoolInfo$statis = yieldPoolInfo.statistic) === null || _yieldPoolInfo$statis === void 0 ? void 0 : _yieldPoolInfo$statis.assetEarning[0].exchangeRate) || 1,
+              slug: yieldPoolInfo.slug,
+              type: yieldPoolInfo.type,
+              chain: yieldPoolInfo.chain,
+              group: yieldPoolInfo.group,
+              isFast: data.fastLeave
+            };
+            historyItem.additionalInfo = additionalInfo;
+          }
+          break;
+        }
+      case ExtrinsicType.TOKEN_APPROVE:
+        {
+          const data = parseTransactionData(transaction.data);
+          const inputAsset = this.state.chainService.getAssetBySlug(data.inputTokenSlug);
+          historyItem.amount = {
+            value: '0',
+            symbol: _getAssetSymbol(inputAsset),
+            decimals: _getAssetDecimals(inputAsset)
+          };
+          break;
+        }
       case ExtrinsicType.UNKNOWN:
         break;
     }
@@ -530,7 +676,7 @@ export default class TransactionService {
     });
 
     // Create Input History Transaction History
-    this.historyService.insertHistories(this.transactionToHistories(id, startBlock, nonce)).catch(console.error);
+    this.state.historyService.insertHistories(this.transactionToHistories(id, startBlock, nonce)).catch(console.error);
     console.debug(`Transaction "${id}" is sent`);
   }
   onHasTransactionHash({
@@ -547,8 +693,12 @@ export default class TransactionService {
     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);
+    this.state.historyService.updateHistoryByExtrinsicHash(id, updateData).catch(console.error);
     console.debug(`Transaction "${id}" is submitted with hash ${extrinsicHash || ''}`);
+    const transaction = this.getTransaction(id);
+    if ([ExtrinsicType.STAKING_JOIN_POOL, ExtrinsicType.JOIN_YIELD_POOL, ExtrinsicType.MINT_LDOT, ExtrinsicType.MINT_QDOT, ExtrinsicType.MINT_SDOT, ExtrinsicType.MINT_VDOT].includes(transaction.extrinsicType)) {
+      this.handlePostEarningTransaction(id);
+    }
   }
   handlePostProcessing(id) {
     // must be done after success/failure to make sure the transaction is finalized
@@ -557,15 +707,15 @@ export default class TransactionService {
       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);
+        sender && this.state.dbService.handleNftTransfer(transaction.chain, [sender.address, ALL_ACCOUNT_KEY], inputData.nftItem).then(() => {
+          this.state.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, {
+        recipient && this.state.dbService.addNft(recipient.address, {
           ...inputData.nftItem,
           owner: recipient.address
         }).catch(console.error);
@@ -573,7 +723,7 @@ export default class TransactionService {
         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);
+      this.state.eventService.emit('transaction.submitStaking', transaction.chain);
     }
   }
   onSuccess({
@@ -589,14 +739,14 @@ export default class TransactionService {
     });
 
     // Write success transaction history
-    this.historyService.updateHistoryByExtrinsicHash(transaction.extrinsicHash, {
+    this.state.historyService.updateHistoryByExtrinsicHash(transaction.extrinsicHash, {
       extrinsicHash,
       status: ExtrinsicStatus.SUCCESS,
       blockNumber: blockNumber || 0,
       blockHash: blockHash || ''
     }).catch(console.error);
-    const info = isHex(extrinsicHash) ? extrinsicHash : getBaseTransactionInfo(transaction, this.chainService.getChainInfoMap());
-    this.notificationService.notify({
+    const info = isHex(extrinsicHash) ? extrinsicHash : getBaseTransactionInfo(transaction, this.state.chainService.getChainInfoMap());
+    this.state.notificationService.notify({
       type: NotificationType.SUCCESS,
       title: t('Transaction completed'),
       message: t('Transaction {{info}} completed', {
@@ -609,7 +759,7 @@ export default class TransactionService {
       },
       notifyViaBrowser: true
     });
-    this.eventService.emit('transaction.done', transaction);
+    this.state.eventService.emit('transaction.done', transaction);
   }
   onFailed({
     blockHash,
@@ -628,14 +778,14 @@ export default class TransactionService {
       });
 
       // Write failed transaction history
-      this.historyService.updateHistoryByExtrinsicHash(transaction.extrinsicHash, {
+      this.state.historyService.updateHistoryByExtrinsicHash(transaction.extrinsicHash, {
         extrinsicHash: extrinsicHash || transaction.extrinsicHash,
         status: nextStatus,
         blockNumber: blockNumber || 0,
         blockHash: blockHash || ''
       }).catch(console.error);
-      const info = isHex(transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash) ? transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash : getBaseTransactionInfo(transaction, this.chainService.getChainInfoMap());
-      this.notificationService.notify({
+      const info = isHex(transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash) ? transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash : getBaseTransactionInfo(transaction, this.state.chainService.getChainInfoMap());
+      this.state.notificationService.notify({
         type: NotificationType.ERROR,
         title: t('Transaction failed'),
         message: t('Transaction {{info}} failed', {
@@ -649,7 +799,7 @@ export default class TransactionService {
         notifyViaBrowser: true
       });
     }
-    this.eventService.emit('transaction.failed', transaction);
+    this.state.eventService.emit('transaction.failed', transaction);
   }
   onTimeOut({
     blockHash,
@@ -691,7 +841,7 @@ export default class TransactionService {
   }
   generateHashPayload(chain, transaction) {
     var _transaction$nonce;
-    const chainInfo = this.chainService.getChainInfoByKey(chain);
+    const chainInfo = this.state.chainService.getChainInfoByKey(chain);
     const txObject = {
       nonce: (_transaction$nonce = transaction.nonce) !== null && _transaction$nonce !== void 0 ? _transaction$nonce : 0,
       gasPrice: addHexPrefix(anyNumberToBN(transaction.gasPrice).toString(16)),
@@ -712,8 +862,8 @@ export default class TransactionService {
   }) {
     var _payload$nonce;
     const payload = transaction;
-    const evmApi = this.chainService.getEvmApi(chain);
-    const chainInfo = this.chainService.getChainInfoByKey(chain);
+    const evmApi = this.state.chainService.getEvmApi(chain);
+    const chainInfo = this.state.chainService.getChainInfoByKey(chain);
     const accountPair = keyring.getPair(address);
     const account = {
       address,
@@ -743,7 +893,7 @@ export default class TransactionService {
 
     // Set unique nonce to avoid transaction errors
     if (!payload.nonce) {
-      const evmApi = this.chainService.getEvmApi(chain);
+      const evmApi = this.state.chainService.getEvmApi(chain);
       payload.nonce = await evmApi.api.eth.getTransactionCount(address);
     }
     if (!payload.chainId) {
@@ -778,7 +928,7 @@ export default class TransactionService {
       extrinsicHash: id
     };
     if (isInjected) {
-      this.requestService.addConfirmation(id, url || EXTENSION_REQUEST_URL, 'evmWatchTransactionRequest', payload, {}).then(async ({
+      this.state.requestService.addConfirmation(id, url || EXTENSION_REQUEST_URL, 'evmWatchTransactionRequest', payload, {}).then(async ({
         isApproved,
         payload
       }) => {
@@ -786,7 +936,7 @@ export default class TransactionService {
           if (!payload) {
             throw new EvmProviderError(EvmProviderErrorType.UNAUTHORIZED, 'Bad signature');
           }
-          const web3Api = this.chainService.getEvmApi(chain).api;
+          const web3Api = this.state.chainService.getEvmApi(chain).api;
 
           // Emit signed event
           emitter.emit('signed', eventData);
@@ -842,7 +992,7 @@ export default class TransactionService {
         emitter.emit('error', eventData);
       });
     } else {
-      this.requestService.addConfirmation(id, url || EXTENSION_REQUEST_URL, 'evmSendTransactionRequest', payload, {}).then(async ({
+      this.state.requestService.addConfirmation(id, url || EXTENSION_REQUEST_URL, 'evmSendTransactionRequest', payload, {}).then(async ({
         isApproved,
         payload
       }) => {
@@ -851,7 +1001,7 @@ export default class TransactionService {
           if (!payload) {
             throw new EvmProviderError(EvmProviderErrorType.UNAUTHORIZED, t('Failed to sign'));
           }
-          const web3Api = this.chainService.getEvmApi(chain).api;
+          const web3Api = this.state.chainService.getEvmApi(chain).api;
           if (!isExternal) {
             signedTransaction = payload;
           } else {
@@ -918,7 +1068,7 @@ export default class TransactionService {
     transaction.signAsync(address, {
       signer: {
         signPayload: async payload => {
-          const signing = await this.requestService.signInternalTransaction(id, address, url || EXTENSION_REQUEST_URL, payload);
+          const signing = await this.state.requestService.signInternalTransaction(id, address, url || EXTENSION_REQUEST_URL, payload);
           return {
             id: new Date().getTime(),
             signature: signing.signature
@@ -930,7 +1080,7 @@ export default class TransactionService {
       emitter.emit('signed', eventData);
 
       // Send transaction
-      const api = this.chainService.getSubstrateApi(chain);
+      const api = this.state.chainService.getSubstrateApi(chain);
       eventData.nonce = rs.nonce.toNumber();
       eventData.startBlock = (await api.api.query.system.number()).toPrimitive();
       this.handleTransactionTimeout(emitter, eventData);
@@ -998,6 +1148,33 @@ export default class TransactionService {
       clearTimeout(timeout);
     });
   }
+  handlePostEarningTransaction(id) {
+    const transaction = this.getTransaction(id);
+    let slug;
+
+    // TODO
+    if ('data' in transaction.data) {
+      slug = transaction.data.data.slug;
+    } else {
+      slug = transaction.data.slug;
+    }
+    const poolHandler = this.state.earningService.getPoolHandler(slug);
+    if (poolHandler) {
+      const type = poolHandler.type;
+      if (type === YieldPoolType.NATIVE_STAKING) {
+        return;
+      }
+    } else {
+      return;
+    }
+    this.state.mintCampaignService.unlockDotCampaign.mintNft({
+      transactionId: id,
+      address: transaction.address,
+      slug: slug,
+      network: transaction.chain,
+      extrinsicHash: transaction.extrinsicHash
+    }).catch(console.error);
+  }
   resetWallet() {
     this.transactionSubject.next({});
   }

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

@@ -30,6 +30,8 @@ export interface SWTransactionInput extends SwInputBase, Partial<Pick<SWTransact
     errors?: SWTransaction['errors'];
     edAsWarning?: boolean;
     isTransferAll?: boolean;
+    resolveOnDone?: boolean;
+    skipFeeValidation?: boolean;
 }
 export declare type SWTransactionResponse = SwInputBase & Pick<SWTransaction, 'warnings' | 'errors'> & Partial<Pick<SWTransaction, 'id' | 'extrinsicHash' | 'status' | 'estimateFee'>>;
 export declare type ValidateTransactionResponseInput = SWTransactionInput;

package/services/transaction-service/utils.js

@@ -5,6 +5,7 @@ import { _getBlockExplorerFromChain, _isPureEvmChain } from '@subwallet/extensio
 
 // @ts-ignore
 export function parseTransactionData(data) {
+  // @ts-ignore
   // eslint-disable-next-line @typescript-eslint/no-unsafe-return
   return data;
 }

package/types/campaigns/index.d.ts

@@ -0,0 +1 @@
+export * from './unlock-dot';

package/types/campaigns/index.js

@@ -0,0 +1,4 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from "./unlock-dot.js";