@subwallet/extension-base 1.3.20-0 → 1.3.21-0

package/services/transaction-service/index.js

@@ -14,7 +14,7 @@ import { parseLiquidStakingEvents, parseLiquidStakingFastUnstakeEvents, parseTra
 import { getBaseTransactionInfo, getTransactionId, isSubstrateTransaction, isTonTransaction } 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 { BasicTxErrorType, YieldPoolType } from '@subwallet/extension-base/types';
+import { BasicTxErrorType, StepStatus, YieldPoolType } from '@subwallet/extension-base/types';
 import { anyNumberToBN, pairToAccount, reformatAddress } from '@subwallet/extension-base/utils';
 import { mergeTransactionAndSignature } from '@subwallet/extension-base/utils/eth/mergeTransactionAndSignature';
 import { isContractAddress, parseContractInput } from '@subwallet/extension-base/utils/eth/parseTransaction';
@@ -26,11 +26,13 @@ import { addHexPrefix } from 'ethereumjs-util';
 import { ethers } from 'ethers';
 import EventEmitter from 'eventemitter3';
 import { t } from 'i18next';
-import { BehaviorSubject, interval as rxjsInterval } from 'rxjs';
+import { BehaviorSubject, interval as rxjsInterval, map as rxjsMap } from 'rxjs';
 import { hexToU8a, isHex } from '@polkadot/util';
 export default class TransactionService {
-  transactionSubject = new BehaviorSubject({});
   watchTransactionSubscribes = {};
+  aliveProcessMap = new Map();
+  transactionSubject = new BehaviorSubject({});
+  aliveProcessSubject = new BehaviorSubject(this.aliveProcessMap);
   get transactions() {
     return this.transactionSubject.getValue();
   }
@@ -59,11 +61,13 @@ export default class TransactionService {
     return [];
   }
   async validateTransaction(transactionInput) {
+    var _transactionInput$ste;
     const validationResponse = {
       ...transactionInput,
       status: undefined,
       errors: transactionInput.errors || [],
-      warnings: transactionInput.warnings || []
+      warnings: transactionInput.warnings || [],
+      processId: (_transactionInput$ste = transactionInput.step) === null || _transactionInput$ste === void 0 ? void 0 : _transactionInput$ste.processId
     };
     const {
       additionalValidator,
@@ -130,6 +134,44 @@ export default class TransactionService {
   getTransactionSubject() {
     return this.transactionSubject;
   }
+  get observables() {
+    const transactionSubject = this.transactionSubject;
+    const aliveProcessSubject = this.aliveProcessSubject;
+    return {
+      get transaction() {
+        return transactionSubject.asObservable();
+      },
+      get aliveProcess() {
+        return aliveProcessSubject.asObservable().pipe(rxjsMap(aliveProcessMap => {
+          const aliveProcessRecord = {};
+          aliveProcessMap.forEach((value, key) => {
+            aliveProcessRecord[key] = value;
+          });
+          return aliveProcessRecord;
+        }));
+      }
+    };
+  }
+  get values() {
+    const transactionSubject = this.transactionSubject;
+    const aliveProcessSubject = this.aliveProcessSubject;
+    return {
+      get transaction() {
+        return transactionSubject.value;
+      },
+      get aliveProcess() {
+        const aliveProcessMap = aliveProcessSubject.value;
+        const aliveProcessRecord = {};
+        aliveProcessMap.forEach((value, key) => {
+          aliveProcessRecord[key] = value;
+        });
+        return aliveProcessRecord;
+      }
+    };
+  }
+  updateAliveProcess() {
+    this.aliveProcessSubject.next(this.aliveProcessMap);
+  }
   fillTransactionDefaultInfo(transaction) {
     const isInternal = !transaction.url;
     const transactionId = getTransactionId(transaction.chainType, transaction.chain, isInternal, isWalletConnectRequest(transaction.id));
@@ -207,6 +249,12 @@ export default class TransactionService {
           resolve();
         }
       });
+      emitter.on('timeout', data => {
+        if (transaction.errorOnTimeOut && data.errors.length > 0) {
+          validatedTransaction.errors.push(...data.errors);
+          resolve();
+        }
+      });
     });
 
     // @ts-ignore
@@ -219,20 +267,39 @@ export default class TransactionService {
     // Send Transaction
     const emitter = await (transaction.chainType === 'substrate' ? this.signAndSendSubstrateTransaction(transaction) : transaction.chainType === 'evm' ? this.signAndSendEvmTransaction(transaction) : this.signAndSendTonTransaction(transaction));
     const {
-      eventsHandler
+      eventsHandler,
+      step
     } = transaction;
     emitter.on('signed', data => {
       this.onSigned(data);
     });
     emitter.on('send', data => {
       this.onSend(data);
+      if (step) {
+        this.updateProcessStepStatus(step, {
+          transactionId: transaction.id,
+          status: StepStatus.SUBMITTING,
+          chain: transaction.chain
+        });
+      }
     });
     emitter.on('extrinsicHash', data => {
       this.onHasTransactionHash(data);
+      if (step) {
+        this.updateProcessStepStatus(step, {
+          extrinsicHash: data.extrinsicHash,
+          status: StepStatus.PROCESSING
+        });
+      }
     });
     emitter.on('success', data => {
       this.handlePostProcessing(data.id);
       this.onSuccess(data);
+      if (step) {
+        this.updateProcessStepStatus(step, {
+          status: StepStatus.COMPLETE
+        });
+      }
     });
     emitter.on('error', data => {
       // this.handlePostProcessing(data.id); // might enable this later
@@ -240,12 +307,33 @@ export default class TransactionService {
         ...data,
         errors: [...data.errors, new TransactionError(BasicTxErrorType.INTERNAL_ERROR)]
       });
+      if (step) {
+        const rejectError = data.errors.find(error => {
+          // TODO: REFACTOR ERROR CODE
+          if ([BasicTxErrorType.UNABLE_TO_SIGN, BasicTxErrorType.USER_REJECT_REQUEST].includes(error.errorType)) {
+            return true;
+          }
+          return false;
+        });
+        if (rejectError) {
+          this.deleteProcess(step);
+        } else {
+          this.updateProcessStepStatus(step, {
+            status: StepStatus.FAILED
+          });
+        }
+      }
     });
     emitter.on('timeout', data => {
       this.onTimeOut({
         ...data,
         errors: [...data.errors, new TransactionError(BasicTxErrorType.TIMEOUT)]
       });
+      if (step) {
+        this.updateProcessStepStatus(step, {
+          status: StepStatus.TIMEOUT
+        });
+      }
     });
 
     // Todo: handle any event with transaction.eventsHandler
@@ -276,6 +364,7 @@ export default class TransactionService {
     return getExplorerLink(chainInfo, transaction.extrinsicHash, 'tx');
   }
   transactionToHistories(id, startBlock, nonce, eventLogs) {
+    var _transaction$step;
     const transaction = this.getTransaction(id);
     const extrinsicType = transaction.extrinsicType;
     const chainInfo = this.state.chainService.getChainInfoByKey(transaction.chain);
@@ -299,7 +388,8 @@ export default class TransactionService {
       blockHash: '',
       // Will be added in next step
       nonce: nonce !== null && nonce !== void 0 ? nonce : 0,
-      startBlock: startBlock || 0
+      startBlock: startBlock || 0,
+      processId: (_transaction$step = transaction.step) === null || _transaction$step === void 0 ? void 0 : _transaction$step.processId
     };
     const nativeAsset = _getChainNativeTokenBasicInfo(chainInfo);
     const baseNativeAmount = {
@@ -650,6 +740,7 @@ export default class TransactionService {
 
     // Create Input History Transaction History
     this.state.historyService.insertHistories(this.transactionToHistories(id, startBlock, nonce)).catch(console.error);
+    this.createProcessNotification(id).catch(console.error);
     console.debug(`Transaction "${id}" is sent`);
   }
   onHasTransactionHash({
@@ -856,6 +947,8 @@ export default class TransactionService {
     address,
     chain,
     id,
+    isPassConfirmation,
+    step,
     transaction,
     url
   }) {
@@ -934,7 +1027,8 @@ export default class TransactionService {
       id,
       errors: [],
       warnings: [],
-      extrinsicHash: id
+      extrinsicHash: id,
+      processId: step === null || step === void 0 ? void 0 : step.processId
     };
     if (isInjected) {
       this.state.requestService.addConfirmation(id, url || EXTENSION_REQUEST_URL, 'evmWatchTransactionRequest', payload, {}).then(async ({
@@ -1001,7 +1095,9 @@ export default class TransactionService {
         emitter.emit('error', eventData);
       });
     } else {
-      this.state.requestService.addConfirmation(id, url || EXTENSION_REQUEST_URL, 'evmSendTransactionRequest', payload, {}).then(async ({
+      this.state.requestService.addConfirmation(id, url || EXTENSION_REQUEST_URL, 'evmSendTransactionRequest', payload, {
+        isPassConfirmation
+      }).then(async ({
         isApproved,
         payload
       }) => {
@@ -1066,6 +1162,8 @@ export default class TransactionService {
     feeCustom,
     id,
     nonNativeTokenPayFeeSlug,
+    signAfterCreate,
+    step,
     transaction,
     url
   }) {
@@ -1077,7 +1175,8 @@ export default class TransactionService {
       id,
       errors: [],
       warnings: [],
-      extrinsicHash: id
+      extrinsicHash: id,
+      processId: step === null || step === void 0 ? void 0 : step.processId
     };
     const extrinsic = transaction;
     // const registry = extrinsic.registry;
@@ -1089,7 +1188,7 @@ export default class TransactionService {
           const {
             signature,
             signedTransaction
-          } = await this.state.requestService.signInternalTransaction(id, address, url || EXTENSION_REQUEST_URL, payload);
+          } = await this.state.requestService.signInternalTransaction(id, address, url || EXTENSION_REQUEST_URL, payload, signAfterCreate);
           return {
             id: new Date().getTime(),
             signature,
@@ -1173,6 +1272,7 @@ export default class TransactionService {
     chain,
     extrinsicType,
     id,
+    step,
     transaction,
     url
   }) {
@@ -1182,7 +1282,8 @@ export default class TransactionService {
       id,
       errors: [],
       warnings: [],
-      extrinsicHash: id
+      extrinsicHash: id,
+      processId: step === null || step === void 0 ? void 0 : step.processId
     };
     const payload = transaction;
     const signer = message => {
@@ -1301,6 +1402,114 @@ export default class TransactionService {
       extrinsicHash: transaction.extrinsicHash
     }).catch(console.error);
   }
+  async createProcessIfNeed(process) {
+    if (!this.aliveProcessMap.has(process.id)) {
+      this.aliveProcessMap.set(process.id, process);
+      this.updateAliveProcess();
+      await this.state.dbService.upsertProcessTransaction(process);
+    }
+  }
+  checkProcessExist(processId) {
+    return this.aliveProcessMap.has(processId);
+  }
+  deleteProcess(step) {
+    const {
+      processId
+    } = step;
+    this.aliveProcessMap.delete(processId);
+    this.state.dbService.deleteProcessTransactionById(processId).catch(console.error);
+    this.updateAliveProcess();
+  }
+  updateProcessStepStatus(step, data) {
+    const {
+      processId,
+      stepId
+    } = step;
+    const process = this.aliveProcessMap.get(processId);
+    if (process) {
+      const step = process.steps.find(item => item.id === stepId);
+      if (step) {
+        Object.assign(step, data);
+        if ([StepStatus.PREPARE || StepStatus.PROCESSING].includes(step.status)) {
+          process.currentStepId = step.id;
+        }
+        if (step.status === StepStatus.COMPLETE) {
+          const nextStep = process.steps.find(item => item.id === stepId + 1);
+          if (nextStep) {
+            nextStep.status = StepStatus.PREPARE;
+            process.currentStepId = nextStep.id;
+          }
+        } else if ([StepStatus.FAILED, StepStatus.TIMEOUT].includes(step.status)) {
+          const nextSteps = process.steps.filter(item => item.id > stepId);
+          nextSteps.forEach(item => {
+            item.status = StepStatus.CANCELLED;
+          });
+        }
+      }
+      if (process.steps.some(item => [StepStatus.PROCESSING, StepStatus.SUBMITTING].includes(item.status))) {
+        process.status = StepStatus.PROCESSING;
+      }
+      if (process.steps.some(item => item.status === StepStatus.TIMEOUT)) {
+        process.status = StepStatus.TIMEOUT;
+      }
+      if (process.steps.every(item => item.status === StepStatus.COMPLETE)) {
+        const lastStep = process.steps[process.steps.length - 1];
+        process.lastTransactionChain = lastStep.chain;
+        process.lastTransactionId = lastStep.transactionId;
+        process.status = StepStatus.COMPLETE;
+      }
+      if (process.steps.some(item => item.status === StepStatus.FAILED)) {
+        process.status = StepStatus.FAILED;
+      }
+      this.aliveProcessMap.set(processId, process);
+      this.state.dbService.upsertProcessTransaction(process).catch(console.error);
+      if ([StepStatus.COMPLETE, StepStatus.FAILED, StepStatus.TIMEOUT].includes(process.status)) {
+        this.aliveProcessMap.delete(processId);
+      }
+      this.updateAliveProcess();
+    } else {
+      this.state.dbService.getProcessTransactionById(processId).then(process => {
+        if (process) {
+          const step = process.steps.find(item => item.id === stepId);
+          if (step && step.status === StepStatus.TIMEOUT && [StepStatus.COMPLETE, StepStatus.FAILED].includes(data.status)) {
+            Object.assign(step, data);
+            const isLastStep = process.steps[process.steps.length - 1].id = stepId;
+            if (isLastStep) {
+              process.status = data.status;
+            }
+            this.state.dbService.upsertProcessTransaction(process).catch(console.error);
+          }
+        }
+      }).catch(console.error);
+    }
+  }
+  async updateProcessInfo(id, combineInfo, step) {
+    const process = this.aliveProcessMap.get(id);
+    if (process) {
+      if (step) {
+        const index = process.steps.findIndex(item => item.id === (step === null || step === void 0 ? void 0 : step.id));
+        if (index !== -1) {
+          process.steps[index] = step;
+        }
+      }
+      if (combineInfo) {
+        process.combineInfo = combineInfo;
+      }
+      this.aliveProcessMap.set(process.id, process);
+      this.updateAliveProcess();
+      await this.state.dbService.upsertProcessTransaction(process);
+    }
+  }
+  async createProcessNotification(transactionId) {
+    var _transaction$step2;
+    const transaction = this.getTransaction(transactionId);
+    if (transaction && (_transaction$step2 = transaction.step) !== null && _transaction$step2 !== void 0 && _transaction$step2.processId) {
+      const process = this.aliveProcessMap.get(transaction.step.processId);
+      if (process) {
+        await this.state.inappNotificationService.createProcessNotification(process);
+      }
+    }
+  }
   resetWallet() {
     this.transactionSubject.next({});
   }

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

@@ -1,6 +1,6 @@
 import { ChainType, ExtrinsicDataTypeMap, ExtrinsicStatus, ExtrinsicType, FeeData, ValidateTransactionResponse } from '@subwallet/extension-base/background/KoniTypes';
 import { TonTransactionConfig } from '@subwallet/extension-base/services/balance-service/transfer/ton-transfer';
-import { BaseRequestSign, TransactionFee } from '@subwallet/extension-base/types';
+import { BaseRequestSign, BriefProcessStep, ProcessTransactionData, TransactionFee } from '@subwallet/extension-base/types';
 import EventEmitter from 'eventemitter3';
 import { TransactionConfig } from 'web3-core';
 import { SubmittableExtrinsic } from '@polkadot/api/promise/types';
@@ -22,10 +22,16 @@ export interface SWTransaction extends ValidateTransactionResponse, Partial<Pick
     transaction: SubmittableExtrinsic | TransactionConfig | TonTransactionConfig;
     additionalValidator?: (inputTransaction: SWTransactionResponse) => Promise<void>;
     eventsHandler?: (eventEmitter: TransactionEmitter) => void;
+    isPassConfirmation?: boolean;
+    errorOnTimeOut?: boolean;
+    signAfterCreate?: (id: string) => void;
+    step?: BriefProcessStep;
+}
+export interface SWTransactionResult extends Omit<SWTransaction, 'transaction' | 'additionalValidator' | 'eventsHandler' | 'process'> {
+    process?: ProcessTransactionData;
 }
-export declare type SWTransactionResult = Omit<SWTransaction, 'transaction' | 'additionalValidator' | 'eventsHandler'>;
 declare type SwInputBase = Pick<SWTransaction, 'address' | 'url' | 'data' | 'extrinsicType' | 'chain' | 'chainType' | 'ignoreWarnings' | 'transferNativeAmount'> & Partial<Pick<SWTransaction, 'additionalValidator' | 'eventsHandler'>>;
-export interface SWTransactionInput extends SwInputBase, Partial<Pick<SWTransaction, 'estimateFee'>>, TransactionFee {
+export interface SWTransactionInput extends SwInputBase, Partial<Pick<SWTransaction, 'estimateFee' | 'signAfterCreate' | 'isPassConfirmation' | 'step' | 'errorOnTimeOut'>>, TransactionFee {
     id?: string;
     transaction?: SWTransaction['transaction'] | null;
     warnings?: SWTransaction['warnings'];
@@ -36,11 +42,14 @@ export interface SWTransactionInput extends SwInputBase, Partial<Pick<SWTransact
     resolveOnDone?: boolean;
     skipFeeValidation?: boolean;
 }
-export declare type SWTransactionResponse = SwInputBase & Pick<SWTransaction, 'warnings' | 'errors'> & Partial<Pick<SWTransaction, 'id' | 'extrinsicHash' | 'status' | 'estimateFee'>> & TransactionFee;
+export declare type SWTransactionResponse = SwInputBase & Pick<SWTransaction, 'warnings' | 'errors'> & Partial<Pick<SWTransaction, 'id' | 'extrinsicHash' | 'status' | 'estimateFee'>> & TransactionFee & {
+    processId?: string;
+};
 export declare type ValidateTransactionResponseInput = SWTransactionInput;
 export declare type TransactionEmitter = EventEmitter<TransactionEventMap>;
 export interface TransactionEventResponse extends ValidateTransactionResponse {
     id: string;
+    processId?: string;
     extrinsicHash?: string;
     blockHash?: string;
     blockNumber?: number;

package/types/index.d.ts

@@ -22,3 +22,4 @@ export * from './service-base';
 export * from './swap';
 export * from './transaction';
 export * from './yield';
+export * from './setting';

package/types/index.js

@@ -15,4 +15,5 @@ export * from "./service-base.js";
 export * from "./swap/index.js";
 export * from "./transaction/index.js";
 export * from "./yield/index.js";
+export * from "./setting.js";
 export {};

package/types/setting.d.ts

@@ -0,0 +1,3 @@
+export declare type RequestChangeAllowOneSign = {
+    allowOneSign: boolean;
+};

package/types/setting.js

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

package/types/swap/index.d.ts

@@ -1,9 +1,9 @@
 import { _ChainInfo } from '@subwallet/chain-list/types';
 import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
 import { AmountData, ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
-import { TransactionData } from '@subwallet/extension-base/types';
 import { BaseStepDetail, CommonOptimalPath, CommonStepFeeInfo } from '@subwallet/extension-base/types/service-base';
 import BigN from 'bignumber.js';
+import { BaseProcessRequestSign, TransactionData } from '../transaction';
 export declare type SwapRate = number;
 export interface SwapPair {
     slug: string;
@@ -54,6 +54,7 @@ export declare enum SwapProviderId {
     POLKADOT_ASSET_HUB = "POLKADOT_ASSET_HUB",
     KUSAMA_ASSET_HUB = "KUSAMA_ASSET_HUB",
     ROCOCO_ASSET_HUB = "ROCOCO_ASSET_HUB",
+    WESTEND_ASSET_HUB = "WESTEND_ASSET_HUB",
     SIMPLE_SWAP = "SIMPLE_SWAP"
 }
 export declare const _SUPPORTED_SWAP_PROVIDERS: SwapProviderId[];
@@ -131,7 +132,7 @@ export interface SwapQuoteResponse {
     aliveUntil: number;
     error?: SwapError;
 }
-export interface SwapSubmitParams {
+export interface SwapSubmitParams extends BaseProcessRequestSign {
     process: CommonOptimalPath;
     currentStep: number;
     quote: SwapQuote;

package/types/swap/index.js

@@ -31,9 +31,12 @@ export let SwapProviderId;
   SwapProviderId["POLKADOT_ASSET_HUB"] = "POLKADOT_ASSET_HUB";
   SwapProviderId["KUSAMA_ASSET_HUB"] = "KUSAMA_ASSET_HUB";
   SwapProviderId["ROCOCO_ASSET_HUB"] = "ROCOCO_ASSET_HUB";
+  SwapProviderId["WESTEND_ASSET_HUB"] = "WESTEND_ASSET_HUB";
   SwapProviderId["SIMPLE_SWAP"] = "SIMPLE_SWAP";
 })(SwapProviderId || (SwapProviderId = {}));
-export const _SUPPORTED_SWAP_PROVIDERS = [SwapProviderId.CHAIN_FLIP_TESTNET, SwapProviderId.CHAIN_FLIP_MAINNET, SwapProviderId.HYDRADX_MAINNET, SwapProviderId.HYDRADX_TESTNET, SwapProviderId.POLKADOT_ASSET_HUB, SwapProviderId.KUSAMA_ASSET_HUB, SwapProviderId.ROCOCO_ASSET_HUB, SwapProviderId.SIMPLE_SWAP];
+export const _SUPPORTED_SWAP_PROVIDERS = [SwapProviderId.CHAIN_FLIP_TESTNET, SwapProviderId.CHAIN_FLIP_MAINNET, SwapProviderId.HYDRADX_MAINNET, SwapProviderId.HYDRADX_TESTNET, SwapProviderId.POLKADOT_ASSET_HUB, SwapProviderId.KUSAMA_ASSET_HUB, SwapProviderId.ROCOCO_ASSET_HUB,
+// SwapProviderId.WESTEND_ASSET_HUB,
+SwapProviderId.SIMPLE_SWAP];
 // process handling
 export let SwapFeeType;
 (function (SwapFeeType) {

package/types/transaction/index.d.ts

@@ -1,4 +1,5 @@
 export * from './data';
 export * from './error';
+export * from './process';
 export * from './request';
 export * from './warning';

package/types/transaction/index.js

@@ -3,5 +3,6 @@
 
 export * from "./data.js";
 export * from "./error.js";
+export * from "./process.js";
 export * from "./request.js";
 export * from "./warning.js";

package/types/transaction/process.d.ts

@@ -0,0 +1,84 @@
+import { _ChainAsset } from '@subwallet/chain-list/types';
+import { TransactionEventResponse } from '@subwallet/extension-base/services/transaction-service/types';
+import { CommonStepDetail, CommonStepFeeInfo } from '../service-base';
+import { SwapPair, SwapProvider, SwapRate, SwapRoute, SwapSubmitParams } from '../swap';
+import { RequestYieldStepSubmit } from '../yield';
+export interface BaseProcessRequestSign {
+    isPassConfirmation?: boolean;
+    onSend?: (rs: TransactionEventResponse) => void;
+    errorOnTimeOut?: boolean;
+    processId?: string;
+}
+export declare enum ProcessType {
+    SWAP = "swap",
+    EARNING = "earning"
+}
+export interface RequestSubmitProcessTransaction {
+    address: string;
+    type: ProcessType;
+    request: SwapSubmitParams | RequestYieldStepSubmit;
+    id: string;
+}
+export declare enum StepStatus {
+    QUEUED = "QUEUED",
+    PREPARE = "PREPARE",
+    SUBMITTING = "SUBMITTING",
+    PROCESSING = "PROCESSING",
+    COMPLETE = "COMPLETE",
+    FAILED = "FAILED",
+    CANCELLED = "CANCELLED",
+    TIMEOUT = "TIMEOUT"
+}
+export declare const PROCESSING_STEP_STATUS: StepStatus[];
+export interface ProcessStep extends CommonStepDetail {
+    fee: CommonStepFeeInfo;
+    status: StepStatus;
+    chain?: string;
+    transactionId?: string;
+    extrinsicHash?: string;
+}
+export interface ProcessTransactionData {
+    id: string;
+    type: ProcessType;
+    address: string;
+    status: StepStatus;
+    steps: ProcessStep[];
+    combineInfo: unknown;
+    currentStepId: number;
+    lastTransactionId?: string;
+    lastTransactionChain?: string;
+}
+export interface BriefProcessStep {
+    processId: string;
+    stepId: number;
+}
+export interface BriefXCMStep {
+    sendingValue: string;
+    originTokenInfo: _ChainAsset;
+    destinationTokenInfo: _ChainAsset;
+}
+export interface BriefSwapStep {
+    pair: SwapPair;
+    fromAmount: string;
+    toAmount: string;
+    rate: SwapRate;
+    provider: SwapProvider;
+    aliveUntil: number;
+    route: SwapRoute;
+}
+export interface ApproveStepMetadata {
+    tokenApprove: string;
+    contractAddress: string;
+    spenderAddress: string;
+    amount?: string;
+}
+export interface RequestSubscribeProcessById {
+    processId: string;
+}
+export interface ResponseSubscribeProcessById {
+    process: ProcessTransactionData | undefined;
+    id: string;
+}
+export interface ResponseSubscribeProcessAlive {
+    processes: Record<string, ProcessTransactionData>;
+}

package/types/transaction/process.js

@@ -0,0 +1,20 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export let ProcessType;
+(function (ProcessType) {
+  ProcessType["SWAP"] = "swap";
+  ProcessType["EARNING"] = "earning";
+})(ProcessType || (ProcessType = {}));
+export let StepStatus;
+(function (StepStatus) {
+  StepStatus["QUEUED"] = "QUEUED";
+  StepStatus["PREPARE"] = "PREPARE";
+  StepStatus["SUBMITTING"] = "SUBMITTING";
+  StepStatus["PROCESSING"] = "PROCESSING";
+  StepStatus["COMPLETE"] = "COMPLETE";
+  StepStatus["FAILED"] = "FAILED";
+  StepStatus["CANCELLED"] = "CANCELLED";
+  StepStatus["TIMEOUT"] = "TIMEOUT";
+})(StepStatus || (StepStatus = {}));
+export const PROCESSING_STEP_STATUS = [StepStatus.PREPARE, StepStatus.SUBMITTING, StepStatus.PROCESSING];

package/types/transaction/request.d.ts

@@ -1,4 +1,5 @@
-import { TransactionFee, TransactionWarningType } from '@subwallet/extension-base/types';
+import { TransactionFee } from '../fee';
+import { TransactionWarningType } from './warning';
 export declare type BaseRequestSign = {
     ignoreWarnings?: TransactionWarningType[];
 };
@@ -10,6 +11,7 @@ export interface RequestBaseTransfer {
     value?: string;
     transferAll?: boolean;
     transferBounceable?: boolean;
+    isPassConfirmation?: boolean;
 }
 export interface RequestCheckTransfer extends RequestBaseTransfer, TransactionFee {
     networkKey: string;

package/types/yield/actions/join/submit.d.ts

@@ -1,6 +1,6 @@
 import { _Address, ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
-import { BaseRequestSign, InternalRequestSign, TransactionData } from '../../../transaction';
-import { NominationPoolInfo, ValidatorInfo, YieldPositionInfo } from '../../info';
+import { BaseProcessRequestSign, BaseRequestSign, InternalRequestSign, TransactionData } from '../../../transaction';
+import { NominationPoolInfo, ValidatorInfo, YieldPoolType, YieldPositionInfo } from '../../info';
 import { OptimalYieldPath } from './step';
 export interface HandleYieldStepData {
     txChain: string;
@@ -29,7 +29,22 @@ export interface SubmitYieldStepData extends AbstractSubmitYieldJoinData {
     feeTokenSlug: string;
 }
 export declare type SubmitYieldJoinData = SubmitYieldStepData | SubmitJoinNativeStaking | SubmitJoinNominationPool;
-export interface HandleYieldStepParams extends BaseRequestSign {
+export declare enum EarningProcessType {
+    NOMINATION_POOL = "NOMINATION_POOL",
+    NATIVE_STAKING = "NATIVE_STAKING",
+    YIELD = "YIELD"
+}
+export interface SummaryEarningProcessData {
+    data: SubmitYieldJoinData;
+    type: EarningProcessType;
+    brief: {
+        token: string;
+        amount: string;
+        chain: string;
+        method: YieldPoolType;
+    };
+}
+export interface HandleYieldStepParams extends BaseRequestSign, BaseProcessRequestSign {
     path: OptimalYieldPath;
     data: SubmitYieldJoinData;
     currentStep: number;

package/types/yield/actions/join/submit.js

@@ -1 +1,11 @@
-export {};
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+// Result after create extrinsic
+
+export let EarningProcessType;
+(function (EarningProcessType) {
+  EarningProcessType["NOMINATION_POOL"] = "NOMINATION_POOL";
+  EarningProcessType["NATIVE_STAKING"] = "NATIVE_STAKING";
+  EarningProcessType["YIELD"] = "YIELD";
+})(EarningProcessType || (EarningProcessType = {}));