@subwallet/extension-base 1.1.29-0 → 1.1.29-beta.0

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

@@ -1,27 +1,15 @@
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
-import { BalanceService } from '@subwallet/extension-base/services/balance-service';
-import { ChainService } from '@subwallet/extension-base/services/chain-service';
-import { EventService } from '@subwallet/extension-base/services/event-service';
-import { HistoryService } from '@subwallet/extension-base/services/history-service';
-import NotificationService from '@subwallet/extension-base/services/notification-service/NotificationService';
-import RequestService from '@subwallet/extension-base/services/request-service';
-import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
+import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
 import { SWTransaction, SWTransactionInput, SWTransactionResponse, TransactionEmitter } from '@subwallet/extension-base/services/transaction-service/types';
 import { BehaviorSubject } from 'rxjs';
 import { TransactionConfig } from 'web3-core';
 import { HexString } from '@polkadot/util/types';
 export default class TransactionService {
-    private readonly balanceService;
-    private readonly chainService;
-    private readonly databaseService;
-    private readonly eventService;
-    private readonly historyService;
-    private readonly notificationService;
-    private readonly requestService;
+    private readonly state;
     private readonly transactionSubject;
     private readonly watchTransactionSubscribes;
     private get transactions();
-    constructor(chainService: ChainService, eventService: EventService, requestService: RequestService, balanceService: BalanceService, historyService: HistoryService, notificationService: NotificationService, databaseService: DatabaseService);
+    constructor(state: KoniState);
     private get allTransactions();
     private get processingTransactions();
     getTransaction(id: string): SWTransaction;
@@ -47,5 +35,6 @@ export default class TransactionService {
     private signAndSendEvmTransaction;
     private signAndSendSubstrateTransaction;
     private handleTransactionTimeout;
+    private handlePostEarningTransaction;
     resetWallet(): void;
 }

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,15 @@ 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;
   }
   get allTransactions() {
     return Object.values(this.transactions);
@@ -96,7 +91,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 +106,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 +140,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 +235,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);
@@ -308,7 +315,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) {
@@ -336,7 +343,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',
@@ -350,7 +357,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,
@@ -363,7 +370,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,
@@ -376,7 +383,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,
@@ -425,17 +432,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'
@@ -454,7 +473,7 @@ export default class TransactionService {
       case ExtrinsicType.STAKING_WITHDRAW:
         {
           const data = parseTransactionData(transaction.data);
-          historyItem.to = data.validatorAddress || '';
+          historyItem.to = data.unstakingInfo.validatorAddress || '';
           historyItem.amount = {
             ...baseNativeAmount,
             value: data.unstakingInfo.claimable || '0'
@@ -479,6 +498,67 @@ 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:
+
+      // 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)
+          };
+          historyItem.additionalInfo = {
+            derivativeTokenSlug: params.derivativeTokenSlug,
+            exchangeRate: params.exchangeRate
+          };
+          eventLogs && !_isChainEvmCompatible(chainInfo) && parseLiquidStakingEvents(historyItem, eventLogs, inputTokenInfo, chainInfo, isFeePaidWithInputAsset, extrinsicType);
+          break;
+        }
+      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);
+          }
+          break;
+        }
+      case ExtrinsicType.REDEEM_STDOT:
+      case ExtrinsicType.REDEEM_LDOT:
+      case ExtrinsicType.REDEEM_SDOT:
+
+      // eslint-disable-next-line no-fallthrough
+      case ExtrinsicType.REDEEM_VDOT:
+        {
+          const data = parseTransactionData(transaction.data);
+          const yieldPoolInfo = data.poolInfo;
+          if (yieldPoolInfo.metadata.derivativeAssets) {
+            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);
+          }
+          break;
+        }
       case ExtrinsicType.UNKNOWN:
         break;
     }
@@ -524,7 +604,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({
@@ -541,8 +621,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
@@ -551,15 +635,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);
@@ -567,7 +651,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({
@@ -583,14 +667,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', {
@@ -603,7 +687,7 @@ export default class TransactionService {
       },
       notifyViaBrowser: true
     });
-    this.eventService.emit('transaction.done', transaction);
+    this.state.eventService.emit('transaction.done', transaction);
   }
   onFailed({
     blockHash,
@@ -622,14 +706,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', {
@@ -643,11 +727,11 @@ export default class TransactionService {
         notifyViaBrowser: true
       });
     }
-    this.eventService.emit('transaction.failed', transaction);
+    this.state.eventService.emit('transaction.failed', transaction);
   }
   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)),
@@ -668,8 +752,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,
@@ -699,7 +783,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) {
@@ -734,7 +818,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
       }) => {
@@ -742,7 +826,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);
@@ -798,7 +882,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
       }) => {
@@ -807,7 +891,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 {
@@ -874,7 +958,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
@@ -886,7 +970,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);
@@ -954,6 +1038,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";

package/types/campaigns/unlock-dot.d.ts

@@ -0,0 +1,71 @@
+export interface UnlockDotAdditionalData {
+    slug: string;
+    network: string;
+    extrinsicHash?: string;
+}
+export interface UnlockDotCheckMintRequest {
+    address: string;
+    additionalData: UnlockDotAdditionalData;
+    category: string;
+    campaignId: number;
+}
+export interface UnlockDotCheckMintResponse {
+    requestId: number | null;
+    userId: number;
+    validUser: boolean;
+    validCampaign: boolean;
+    validCategory: boolean;
+    isWhiteList: boolean;
+    isOwner: boolean;
+    hasBalance: boolean;
+    notDuplicated: boolean;
+    inMintingTime: boolean;
+}
+export interface UnlockDotMintedData {
+    id: number;
+    campaignId: number;
+    collectionId: number;
+    userId: number;
+    address: string;
+    status: string;
+    extrinsicHash: string;
+    mintCategory: string;
+    mintDate: null;
+    rmrkNftId: string;
+    nftName: string;
+    nftImage: string;
+    recipient: string;
+    blockNumber: number;
+    additionalData: string;
+}
+export declare type UnlockDotTransactionNft = UnlockDotMintedData | undefined | Pick<UnlockDotMintedData, 'nftImage'>;
+export interface UnlockDotFetchMintedRequest {
+    address: string;
+}
+export declare type UnlockDotFetchMintedResponse = UnlockDotMintedData[];
+export interface UnlockDotMintSubmitRequest {
+    recipient: string;
+    requestId: number;
+}
+export declare type UnlockDotMintSubmitResponse = UnlockDotMintedData;
+export interface UnlockDotCheckMintData {
+    address: string;
+    slug: string;
+    network: string;
+    extrinsicHash?: string;
+}
+export interface UnlockDotSubmitMintData {
+    transactionId: string;
+    address: string;
+    slug: string;
+    network: string;
+    extrinsicHash: string;
+}
+export interface RequestUnlockDotCheckCanMint {
+    address: string;
+    slug: string;
+    network: string;
+}
+export interface RequestUnlockDotSubscribeMintedData {
+    transactionId: string;
+}

package/types/campaigns/unlock-dot.js

@@ -0,0 +1 @@
+export {};

package/types/index.d.ts

@@ -5,7 +5,12 @@ export interface Message extends MessageEvent {
         origin: string;
         response?: string;
         subscription?: string;
+        sender?: string;
     };
 }
 export * from './balance';
 export * from './buy';
+export * from './campaigns';
+export * from './ordinal';
+export * from './transaction';
+export * from './yield';