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

package/cjs/koni/background/handlers/Extension.js

@@ -837,6 +837,13 @@ class KoniExtension {
     this.#koniState.updateSetting('isShowBalance', enable);
     return true;
   }
+  setAllowOneSign(_ref25) {
+    let {
+      allowOneSign
+    } = _ref25;
+    this.#koniState.updateSetting('allowOneSign', allowOneSign);
+    return true;
+  }
   async subscribeAuthUrls(id, port) {
     const cb = (0, _subscriptions.createSubscription)(id, port);
     const authorizeUrlSubscription = this.#koniState.subscribeAuthorizeUrlSubject().subscribe({
@@ -882,10 +889,10 @@ class KoniExtension {
   async getPrice() {
     return this.#koniState.priceService.getPrice();
   }
-  async setPriceCurrency(_ref25) {
+  async setPriceCurrency(_ref26) {
     let {
       currency
-    } = _ref25;
+    } = _ref26;
     return await this.#koniState.priceService.setPriceCurrency(currency);
   }
   subscribePrice(id, port) {
@@ -1093,11 +1100,11 @@ class KoniExtension {
     // Re-filter
     return historySubject.getValue().filter(item => addresses.some(address => (0, _utils7.isSameAddress)(item.address, address)));
   }
-  subscribeHistoryByChainAndAddress(_ref26, id, port) {
+  subscribeHistoryByChainAndAddress(_ref27, id, port) {
     let {
       address,
       chain
-    } = _ref26;
+    } = _ref27;
     const cb = (0, _subscriptions.createSubscription)(id, port);
     const subscribeHistoriesResponse = this.#koniState.historyService.subscribeHistories(chain, address, cb);
     this.createUnsubscriptionHandle(id, subscribeHistoriesResponse.unsubscribe);
@@ -1330,6 +1337,7 @@ class KoniExtension {
       feeCustom,
       feeOption,
       from,
+      isPassConfirmation,
       nonNativeTokenPayFeeSlug,
       originNetworkKey,
       to,
@@ -1453,6 +1461,7 @@ class KoniExtension {
       nonNativeTokenPayFeeSlug,
       isTransferAll: transferAll,
       isTransferLocalTokenAndPayThatTokenAsFee,
+      isPassConfirmation,
       errors,
       additionalValidator: additionalValidator,
       eventsHandler: eventsHandler
@@ -1574,21 +1583,21 @@ class KoniExtension {
   disableChain(networkKey) {
     return this.#koniState.disableChain(networkKey);
   }
-  async enableChain(_ref27) {
+  async enableChain(_ref28) {
     let {
       chainSlug,
       enableTokens
-    } = _ref27;
+    } = _ref28;
     return await this.#koniState.enableChain(chainSlug, enableTokens);
   }
   async reconnectChain(chainSlug) {
     return this.#koniState.chainService.reconnectChain(chainSlug);
   }
-  async validateNetwork(_ref28) {
+  async validateNetwork(_ref29) {
     let {
       existedChainSlug,
       provider
-    } = _ref28;
+    } = _ref29;
     return await this.#koniState.validateCustomChain(provider, existedChainSlug);
   }
   resetDefaultNetwork() {
@@ -1679,13 +1688,13 @@ class KoniExtension {
   async validateCustomAsset(data) {
     return await this.#koniState.validateCustomAsset(data);
   }
-  async getAddressTransferableBalance(_ref29) {
+  async getAddressTransferableBalance(_ref30) {
     let {
       address,
       extrinsicType,
       networkKey,
       token
-    } = _ref29;
+    } = _ref30;
     if (token && _constants2._MANTA_ZK_CHAIN_GROUP.includes(networkKey)) {
       const tokenInfo = this.#koniState.chainService.getAssetBySlug(token);
       if (tokenInfo.symbol.startsWith(_constants2._ZK_ASSET_PREFIX)) {
@@ -1694,13 +1703,13 @@ class KoniExtension {
     }
     return await this.#koniState.balanceService.getTransferableBalance(address, networkKey, token, extrinsicType);
   }
-  async getAddressTotalBalance(_ref30) {
+  async getAddressTotalBalance(_ref31) {
     let {
       address,
       extrinsicType,
       networkKey,
       token
-    } = _ref30;
+    } = _ref31;
     return await this.#koniState.balanceService.getTotalBalance(address, networkKey, token, extrinsicType);
   }
   async subscribeMaxTransferable(request, id, port) {
@@ -1748,11 +1757,11 @@ class KoniExtension {
       freeBalance: freeBalanceSubject,
       fee: feeSubject
     }).subscribe({
-      next: _ref31 => {
+      next: _ref32 => {
         let {
           fee,
           freeBalance
-        } = _ref31;
+        } = _ref32;
         (0, _utils7.calculateMaxTransferable)(id, _request, freeBalance, fee).then(cb).catch(console.error);
       }
     });
@@ -1786,13 +1795,13 @@ class KoniExtension {
     });
     return (0, _utils7.calculateMaxTransferable)(id, _request, freeBalance, fee);
   }
-  async subscribeAddressTransferableBalance(_ref32, id, port) {
+  async subscribeAddressTransferableBalance(_ref33, id, port) {
     let {
       address,
       extrinsicType,
       networkKey,
       token
-    } = _ref32;
+    } = _ref33;
     const cb = (0, _subscriptions.createSubscription)(id, port);
     const convertData = data => {
       return {
@@ -1843,11 +1852,11 @@ class KoniExtension {
       isSendingSelf
     };
   }
-  async enableChains(_ref33) {
+  async enableChains(_ref34) {
     let {
       chainSlugs,
       enableTokens
-    } = _ref33;
+    } = _ref34;
     try {
       await Promise.all(chainSlugs.map(chainSlug => this.enableChain({
         chainSlug,
@@ -1968,30 +1977,30 @@ class KoniExtension {
 
   // Parse transaction
 
-  parseSubstrateTransaction(_ref34) {
+  parseSubstrateTransaction(_ref35) {
     let {
       data,
       networkKey
-    } = _ref34;
+    } = _ref35;
     const apiProps = this.#koniState.getSubstrateApi(networkKey);
     const apiPromise = apiProps.api;
     return (0, _parseTransaction.parseSubstrateTransaction)(data, apiPromise);
   }
-  async parseEVMRLP(_ref35) {
+  async parseEVMRLP(_ref36) {
     let {
       data
-    } = _ref35;
+    } = _ref36;
     return await (0, _parseTransaction2.parseEvmRlp)(data, this.#koniState.getChainInfoMap(), this.#koniState.getEvmApiMap());
   }
 
   // Sign
 
-  qrSignSubstrate(_ref36) {
+  qrSignSubstrate(_ref37) {
     let {
       address,
       data,
       networkKey
-    } = _ref36;
+    } = _ref37;
     const pair = _uiKeyring.keyring.getPair(address);
     (0, _util.assert)(pair, (0, _i18next.t)('Unable to find account'));
     if (pair.isLocked) {
@@ -2008,13 +2017,13 @@ class KoniExtension {
       signature: signed
     };
   }
-  async qrSignEVM(_ref37) {
+  async qrSignEVM(_ref38) {
     let {
       address,
       chainId,
       message,
       type
-    } = _ref37;
+    } = _ref38;
     let signed;
     const network = this.getNetworkJsonByChainId(chainId);
     if (!network) {
@@ -2098,11 +2107,11 @@ class KoniExtension {
     });
     return this.#koniState.getNominatorMetadata();
   }
-  async getBondingOptions(_ref38) {
+  async getBondingOptions(_ref39) {
     let {
       chain,
       type
-    } = _ref38;
+    } = _ref39;
     const apiProps = this.#koniState.getSubstrateApi(chain);
     const chainInfo = this.#koniState.getChainInfo(chain);
     const chainStakingMetadata = await this.#koniState.getStakingMetadataByChain(chain, type);
@@ -2292,12 +2301,12 @@ class KoniExtension {
   }
 
   // EVM Transaction
-  async parseContractInput(_ref39) {
+  async parseContractInput(_ref40) {
     let {
       chainId,
       contract,
       data
-    } = _ref39;
+    } = _ref40;
     const network = this.getNetworkJsonByChainId(chainId);
     return await (0, _parseTransaction2.parseContractInput)(data, contract, network);
   }
@@ -2397,10 +2406,10 @@ class KoniExtension {
 
   // Unlock wallet
 
-  keyringUnlock(_ref40) {
+  keyringUnlock(_ref41) {
     let {
       password
-    } = _ref40;
+    } = _ref41;
     try {
       _uiKeyring.keyring.unlockKeyring(password);
       // this.#koniState.initMantaPay(password)
@@ -2431,11 +2440,11 @@ class KoniExtension {
 
   // Export mnemonic
 
-  keyringExportMnemonic(_ref41) {
+  keyringExportMnemonic(_ref42) {
     let {
       address,
       password
-    } = _ref41;
+    } = _ref42;
     const pair = _uiKeyring.keyring.getPair(address);
     const result = pair.exportMnemonic(password);
     return {
@@ -2445,10 +2454,10 @@ class KoniExtension {
 
   // Reset wallet
 
-  async resetWallet(_ref42) {
+  async resetWallet(_ref43) {
     let {
       resetAll
-    } = _ref42;
+    } = _ref43;
     try {
       await this.#koniState.resetWallet(resetAll);
       return {
@@ -2464,10 +2473,10 @@ class KoniExtension {
   }
 
   // Signing substrate request
-  async signingApprovePasswordV2(_ref43) {
+  async signingApprovePasswordV2(_ref44) {
     let {
       id
-    } = _ref43;
+    } = _ref44;
     const queued = this.#koniState.getSignRequest(id);
     (0, _util.assert)(queued, (0, _i18next.t)('Unable to proceed. Please try again'));
     const {
@@ -2625,39 +2634,56 @@ class KoniExtension {
   getSupportedSmartContractTypes() {
     return this.#koniState.getSupportedSmartContractTypes();
   }
-  getTransaction(_ref44) {
+  getTransaction(_ref45) {
     let {
       id
-    } = _ref44;
+    } = _ref45;
     const {
       transaction,
       ...transactionResult
     } = this.#koniState.transactionService.getTransaction(id);
     return transactionResult;
   }
-  subscribeTransactions(id, port) {
+  async subscribeTransactions(id, port) {
     const cb = (0, _subscriptions.createSubscription)(id, port);
-    function convertRs(rs) {
-      return Object.fromEntries(Object.entries(rs).map(_ref45 => {
-        let [key, value] = _ref45;
+    function convertRs(rs, processMap) {
+      return Object.fromEntries(Object.entries(rs).map(_ref46 => {
+        let [key, value] = _ref46;
         const {
           additionalValidator,
           eventsHandler,
+          step,
           transaction,
-          ...transactionResult
+          ..._transactionResult
         } = value;
+        const transactionResult = _transactionResult;
+        if (step !== null && step !== void 0 && step.processId) {
+          const process = processMap[step.processId];
+          if (process) {
+            transactionResult.process = process;
+          }
+        }
         return [key, transactionResult];
       }));
     }
     const transactionsSubject = this.#koniState.transactionService.getTransactionSubject();
-    const transactionsSubscription = transactionsSubject.subscribe(rs => {
-      cb(convertRs(rs));
+    const transactionsObservable = transactionsSubject.asObservable();
+    const processTransactionObservable = this.#koniState.dbService.observableProcessTransactions();
+    const subscription = (0, _rxjs.combineLatest)({
+      transactions: transactionsObservable,
+      processMap: processTransactionObservable
+    }).subscribe(_ref47 => {
+      let {
+        processMap,
+        transactions
+      } = _ref47;
+      cb(convertRs(transactions, processMap));
     });
     port.onDisconnect.addListener(() => {
-      transactionsSubscription.unsubscribe();
+      subscription.unsubscribe();
       this.cancelSubscription(id);
     });
-    return convertRs(transactionsSubject.getValue());
+    return convertRs(transactionsSubject.getValue(), await this.#koniState.dbService.getProcessTransactions());
   }
   subscribeNotifications(id, port) {
     const cb = (0, _subscriptions.createSubscription)(id, port);
@@ -2671,10 +2697,10 @@ class KoniExtension {
     });
     return notificationSubject.value;
   }
-  async reloadCron(_ref46) {
+  async reloadCron(_ref48) {
     let {
       data
-    } = _ref46;
+    } = _ref48;
     if (data === 'nft') {
       return await this.#koniState.reloadNft();
     } else if (data === 'staking') {
@@ -2717,10 +2743,10 @@ class KoniExtension {
   }
 
   // Phishing detect
-  async passPhishingPage(_ref47) {
+  async passPhishingPage(_ref49) {
     let {
       url
-    } = _ref47;
+    } = _ref49;
     return await this.#koniState.approvePassPhishingPage(url);
   }
 
@@ -2741,10 +2767,10 @@ class KoniExtension {
   /// Wallet connect
 
   // Connect
-  async connectWalletConnect(_ref48) {
+  async connectWalletConnect(_ref50) {
     let {
       uri
-    } = _ref48;
+    } = _ref50;
     await this.#koniState.walletConnectService.connect(uri);
     return true;
   }
@@ -2757,11 +2783,11 @@ class KoniExtension {
     });
     return this.#koniState.requestService.allConnectWCRequests;
   }
-  async approveWalletConnectSession(_ref49) {
+  async approveWalletConnectSession(_ref51) {
     let {
       accounts: selectedAccounts,
       id
-    } = _ref49;
+    } = _ref51;
     const request = this.#koniState.requestService.getConnectWCRequest(id);
     if ((0, _helpers2.isProposalExpired)(request.request.params)) {
       throw new Error('The proposal has been expired');
@@ -2773,8 +2799,8 @@ class KoniExtension {
     const availableNamespaces = {};
     const namespaces = {};
     const chainInfoMap = this.#koniState.getChainInfoMap();
-    Object.entries(requiredNamespaces).forEach(_ref50 => {
-      let [key, namespace] = _ref50;
+    Object.entries(requiredNamespaces).forEach(_ref52 => {
+      let [key, namespace] = _ref52;
       if ((0, _helpers2.isSupportWalletConnectNamespace)(key)) {
         if (namespace.chains) {
           const unSupportChains = namespace.chains.filter(chain => !(0, _helpers2.isSupportWalletConnectChain)(chain, chainInfoMap));
@@ -2787,8 +2813,8 @@ class KoniExtension {
         throw new Error((0, _utils8.getSdkError)('UNSUPPORTED_NAMESPACE_KEY').message + ' ' + key);
       }
     });
-    Object.entries(optionalNamespaces).forEach(_ref51 => {
-      let [key, namespace] = _ref51;
+    Object.entries(optionalNamespaces).forEach(_ref53 => {
+      let [key, namespace] = _ref53;
       if ((0, _helpers2.isSupportWalletConnectNamespace)(key)) {
         if (namespace.chains) {
           const supportChains = namespace.chains.filter(chain => (0, _helpers2.isSupportWalletConnectChain)(chain, chainInfoMap)) || [];
@@ -2812,8 +2838,8 @@ class KoniExtension {
         }
       }
     });
-    Object.entries(availableNamespaces).forEach(_ref52 => {
-      let [key, namespace] = _ref52;
+    Object.entries(availableNamespaces).forEach(_ref54 => {
+      let [key, namespace] = _ref54;
       if (namespace.chains) {
         const accounts = selectedAccounts.filter(address => {
           const [_namespace] = address.split(':');
@@ -2837,10 +2863,10 @@ class KoniExtension {
     request.resolve();
     return true;
   }
-  async rejectWalletConnectSession(_ref53) {
+  async rejectWalletConnectSession(_ref55) {
     let {
       id
-    } = _ref53;
+    } = _ref55;
     const request = this.#koniState.requestService.getConnectWCRequest(id);
     const wcId = request.request.id;
     if ((0, _helpers2.isProposalExpired)(request.request.params)) {
@@ -2862,10 +2888,10 @@ class KoniExtension {
     });
     return this.#koniState.walletConnectService.sessions;
   }
-  async disconnectWalletConnectSession(_ref54) {
+  async disconnectWalletConnectSession(_ref56) {
     let {
       topic
-    } = _ref54;
+    } = _ref56;
     await this.#koniState.walletConnectService.disconnect(topic);
     return true;
   }
@@ -2878,18 +2904,18 @@ class KoniExtension {
     });
     return this.#koniState.requestService.allNotSupportWCRequests;
   }
-  approveWalletConnectNotSupport(_ref55) {
+  approveWalletConnectNotSupport(_ref57) {
     let {
       id
-    } = _ref55;
+    } = _ref57;
     const request = this.#koniState.requestService.getNotSupportWCRequest(id);
     request.resolve();
     return true;
   }
-  rejectWalletConnectNotSupport(_ref56) {
+  rejectWalletConnectNotSupport(_ref58) {
     let {
       id
-    } = _ref56;
+    } = _ref58;
     const request = this.#koniState.requestService.getNotSupportWCRequest(id);
     request.reject(new Error('USER_REJECTED'));
     return true;
@@ -2897,11 +2923,11 @@ class KoniExtension {
 
   /// Manta
 
-  async enableMantaPay(_ref57) {
+  async enableMantaPay(_ref59) {
     let {
       address,
       password
-    } = _ref57;
+    } = _ref59;
     // always takes the current account
     function timeout() {
       return new Promise(resolve => setTimeout(resolve, 1500));
@@ -2991,11 +3017,11 @@ class KoniExtension {
   async disableMantaPay(address) {
     return this.#koniState.disableMantaPay(address);
   }
-  async isTonBounceableAddress(_ref58) {
+  async isTonBounceableAddress(_ref60) {
     let {
       address,
       chain
-    } = _ref58;
+    } = _ref60;
     try {
       const tonApi = this.#koniState.getTonApi(chain);
       const state = await tonApi.getAccountState(address);
@@ -3041,10 +3067,10 @@ class KoniExtension {
 
   /* Metadata */
 
-  async findRawMetadata(_ref59) {
+  async findRawMetadata(_ref61) {
     let {
       genesisHash
-    } = _ref59;
+    } = _ref61;
     const {
       metadata,
       specVersion,
@@ -3058,20 +3084,20 @@ class KoniExtension {
       userExtensions
     };
   }
-  async calculateMetadataHash(_ref60) {
+  async calculateMetadataHash(_ref62) {
     let {
       chain
-    } = _ref60;
+    } = _ref62;
     const hash = await this.#koniState.calculateMetadataHash(chain);
     return {
       metadataHash: hash || ''
     };
   }
-  async shortenMetadata(_ref61) {
+  async shortenMetadata(_ref63) {
     let {
       chain,
       txBlob
-    } = _ref61;
+    } = _ref63;
     const shorten = await this.#koniState.shortenMetadata(chain, txBlob);
     return {
       txMetadata: shorten || ''
@@ -3121,12 +3147,29 @@ class KoniExtension {
   async handleYieldStep(inputData) {
     const {
       data,
-      path
+      errorOnTimeOut,
+      isPassConfirmation,
+      onSend,
+      path,
+      processId
     } = inputData;
     const {
       address
     } = data;
+    let step;
+    if (processId) {
+      const _step = path.steps[inputData.currentStep];
+      step = {
+        processId,
+        stepId: _step.id
+      };
+    }
     if (!data) {
+      if (step) {
+        this.#koniState.transactionService.updateProcessStepStatus(step, {
+          status: _types3.StepStatus.FAILED
+        });
+      }
       return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types3.BasicTxErrorType.INTERNAL_ERROR)]);
     }
     const isLastStep = inputData.currentStep + 1 === path.steps.length;
@@ -3136,6 +3179,11 @@ class KoniExtension {
     }); // TODO: validate, set to fail upon submission
 
     if (yieldValidation.length > 0) {
+      if (step) {
+        this.#koniState.transactionService.updateProcessStepStatus(step, {
+          status: _types3.StepStatus.FAILED
+        });
+      }
       return this.#koniState.transactionService.generateBeforeHandleResponseErrors(yieldValidation);
     }
 
@@ -3149,7 +3197,66 @@ class KoniExtension {
       txData
     } = await this.#koniState.earningService.handleYieldJoin(inputData);
     const isPoolSupportAlternativeFee = this.#koniState.earningService.isPoolSupportAlternativeFee(inputData.data.slug);
+    const poolHandler = this.#koniState.earningService.getPoolHandler(data.slug);
     const isMintingStep = _utils2.YIELD_EXTRINSIC_TYPES.includes(extrinsicType);
+    const eventsHandler = eventEmitter => {
+      if (onSend) {
+        eventEmitter.on('send', onSend);
+      }
+    };
+    if (processId && poolHandler) {
+      const convertFee = fee => {
+        return {
+          feeComponent: [{
+            amount: fee.amount || '0',
+            // TODO: Add fee type
+            feeType: _types3.SwapFeeType.NETWORK_FEE,
+            tokenSlug: fee.slug
+          }],
+          defaultFeeToken: fee.slug,
+          feeOptions: [fee.slug]
+        };
+      };
+      if (!this.#koniState.transactionService.checkProcessExist(processId) && step) {
+        const lastStep = path.steps[path.steps.length - 1];
+        const combineInfo = {
+          // In real case, only `YIELD` have multiple steps
+          type: lastStep.type === _types3.YieldStepType.JOIN_NOMINATION_POOL ? _types3.EarningProcessType.NOMINATION_POOL : lastStep.type === _types3.YieldStepType.NOMINATE ? _types3.EarningProcessType.NATIVE_STAKING : _types3.EarningProcessType.YIELD,
+          data,
+          brief: {
+            amount: data.amount,
+            chain: poolHandler.chain,
+            token: poolHandler.metadataInfo.inputAsset,
+            method: poolHandler.type
+          }
+        };
+        await this.#koniState.transactionService.createProcessIfNeed({
+          id: processId,
+          address: (0, _utils7.reformatAddress)(address),
+          type: _types3.ProcessType.EARNING,
+          combineInfo,
+          currentStepId: step.stepId,
+          steps: path.steps.map((step, index) => {
+            const fee = convertFee(path.totalFee[index]);
+            if (![_types3.YieldStepType.XCM, _types3.YieldStepType.DEFAULT, _types3.YieldStepType.TOKEN_APPROVAL].includes(step.type)) {
+              const metadata = data;
+              return {
+                ...step,
+                status: _types3.StepStatus.QUEUED,
+                fee,
+                metadata: metadata
+              };
+            }
+            return {
+              ...step,
+              fee,
+              status: _types3.StepStatus.QUEUED
+            };
+          }).filter(step => step.type !== _types3.YieldStepType.DEFAULT),
+          status: _types3.StepStatus.QUEUED
+        });
+      }
+    }
     return await this.#koniState.transactionService.handleTransaction({
       address,
       chain: txChain,
@@ -3161,7 +3268,11 @@ class KoniExtension {
       chainType,
       resolveOnDone: !isLastStep,
       transferNativeAmount,
-      skipFeeValidation: isMintingStep && isPoolSupportAlternativeFee
+      skipFeeValidation: isMintingStep && isPoolSupportAlternativeFee,
+      errorOnTimeOut,
+      ...this.createPassConfirmationParams(isPassConfirmation),
+      eventsHandler,
+      step
     });
   }
   async handleYieldLeave(params) {
@@ -3317,18 +3428,18 @@ class KoniExtension {
 
   /* Campaign */
 
-  unlockDotCheckCanMint(_ref62) {
+  unlockDotCheckCanMint(_ref64) {
     let {
       address,
       network,
       slug
-    } = _ref62;
+    } = _ref64;
     return this.#koniState.mintCampaignService.unlockDotCampaign.canMint(address, slug, network);
   }
-  unlockDotSubscribeMintedData(id, port, _ref63) {
+  unlockDotSubscribeMintedData(id, port, _ref65) {
     let {
       transactionId
-    } = _ref63;
+    } = _ref65;
     const cb = (0, _subscriptions.createSubscription)(id, port);
     const subscription = this.#koniState.mintCampaignService.unlockDotCampaign.subscribeMintedNft(transactionId, cb);
     this.createUnsubscriptionHandle(id, subscription.unsubscribe);
@@ -3360,10 +3471,10 @@ class KoniExtension {
     });
     return filterBanner(await this.#koniState.campaignService.getProcessingCampaign());
   }
-  async completeCampaignBanner(_ref64) {
+  async completeCampaignBanner(_ref66) {
     let {
       slug
-    } = _ref64;
+    } = _ref66;
     const campaign = await this.#koniState.dbService.getCampaign(slug);
     if (campaign) {
       await this.#koniState.dbService.upsertCampaign({
@@ -3508,11 +3619,28 @@ class KoniExtension {
   async handleSwapStep(inputData) {
     const {
       address,
+      errorOnTimeOut,
+      isPassConfirmation,
+      onSend,
       process,
+      processId,
       quote,
       recipient
     } = inputData;
+    let step;
+    if (processId) {
+      const _step = process.steps[inputData.currentStep];
+      step = {
+        processId,
+        stepId: _step.id
+      };
+    }
     if (!quote || !address || !process) {
+      if (step) {
+        this.#koniState.transactionService.updateProcessStepStatus(step, {
+          status: _types3.StepStatus.FAILED
+        });
+      }
       return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new _TransactionError.TransactionError(_types3.BasicTxErrorType.INTERNAL_ERROR)]);
     }
     const isLastStep = inputData.currentStep + 1 === process.steps.length;
@@ -3523,6 +3651,11 @@ class KoniExtension {
       recipient
     });
     if (swapValidations.length > 0) {
+      if (step) {
+        this.#koniState.transactionService.updateProcessStepStatus(step, {
+          status: _types3.StepStatus.FAILED
+        });
+      }
       return this.#koniState.transactionService.generateBeforeHandleResponseErrors(swapValidations);
     }
 
@@ -3538,6 +3671,85 @@ class KoniExtension {
     // const chosenFeeToken = process.steps.findIndex((step) => step.type === SwapStepType.SET_FEE_TOKEN) > -1;
     // const allowSkipValidation = [ExtrinsicType.SET_FEE_TOKEN, ExtrinsicType.SWAP].includes(extrinsicType);
 
+    const eventsHandler = eventEmitter => {
+      if (onSend) {
+        eventEmitter.on('send', onSend);
+      }
+    };
+    if (processId) {
+      const _step = process.steps[inputData.currentStep];
+      if (!this.#koniState.transactionService.checkProcessExist(processId) && step) {
+        const combineInfo = {
+          provider: quote.provider,
+          slippage: inputData.slippage,
+          address,
+          recipient,
+          quote,
+          process
+        };
+        await this.#koniState.transactionService.createProcessIfNeed({
+          id: processId,
+          address: (0, _utils7.reformatAddress)(address),
+          type: _types3.ProcessType.SWAP,
+          currentStepId: step.stepId,
+          combineInfo,
+          steps: inputData.process.steps.map((step, index) => {
+            const fee = inputData.process.totalFee[index];
+            if (step.type === _types3.SwapStepType.SWAP) {
+              const metadata = {
+                pair: quote.pair,
+                aliveUntil: quote.aliveUntil,
+                fromAmount: quote.fromAmount,
+                rate: quote.rate,
+                provider: quote.provider,
+                route: quote.route,
+                toAmount: quote.toAmount
+              };
+              return {
+                ...step,
+                status: _types3.StepStatus.QUEUED,
+                fee,
+                metadata: metadata
+              };
+            }
+            return {
+              ...step,
+              fee,
+              status: _types3.StepStatus.QUEUED
+            };
+          }).filter(step => step.type !== _types3.CommonStepType.DEFAULT),
+          status: _types3.StepStatus.QUEUED
+        });
+      }
+      const isLastStep = inputData.currentStep === process.steps.length - 1;
+      if (isLastStep) {
+        const metadata = {
+          pair: quote.pair,
+          aliveUntil: quote.aliveUntil,
+          fromAmount: quote.fromAmount,
+          rate: quote.rate,
+          provider: quote.provider,
+          route: quote.route,
+          toAmount: quote.toAmount
+        };
+        const step = {
+          ..._step,
+          // In case one sign, status already set to prepare before
+          status: process.steps.length > 2 ? _types3.StepStatus.PREPARE : _types3.StepStatus.QUEUED,
+          fee: process.totalFee[inputData.currentStep],
+          metadata: metadata
+        };
+        const combineInfo = {
+          provider: quote.provider,
+          slippage: inputData.slippage,
+          address,
+          recipient,
+          quote,
+          process
+        };
+        await this.#koniState.transactionService.updateProcessInfo(processId, combineInfo, step);
+      }
+    }
     return await this.#koniState.transactionService.handleTransaction({
       address,
       chain: txChain,
@@ -3548,7 +3760,11 @@ class KoniExtension {
       // change this depends on step
       chainType,
       resolveOnDone: !isLastStep,
-      transferNativeAmount
+      transferNativeAmount,
+      ...this.createPassConfirmationParams(isPassConfirmation),
+      errorOnTimeOut,
+      eventsHandler,
+      step
       // skipFeeValidation: chosenFeeToken && allowSkipValidation
     });
   }
@@ -3677,6 +3893,208 @@ class KoniExtension {
 
   /* Popular tokens */
 
+  /* Multi process */
+
+  async handleSubmitProcessTransaction(_request) {
+    const {
+      address,
+      id: processId,
+      request: requestData,
+      type
+    } = _request;
+    const pair = _uiKeyring.keyring.getPair(address);
+    if (!pair) {
+      throw new Error('Pair not found');
+    }
+    const signMode = (0, _utils7.getAccountSignMode)(address, pair.meta);
+    if (signMode !== _types3.AccountSignMode.PASSWORD) {
+      throw new Error('Account can not use this feature');
+    }
+    const setting = await new Promise(resolve => this.#koniState.settingService.getSettings(resolve));
+    if (!setting.allowOneSign) {
+      throw new Error('Wallet not enable this feature');
+    }
+    switch (type) {
+      case _types3.ProcessType.EARNING:
+
+      // eslint-disable-next-line no-fallthrough
+      case _types3.ProcessType.SWAP:
+        {
+          const currentStep = requestData.currentStep;
+          let stepNums;
+          let submitData;
+          let waitXcmData;
+          if (type === _types3.ProcessType.EARNING) {
+            const data = requestData;
+            const poolHandler = this.#koniState.earningService.getPoolHandler(data.data.slug);
+            if (poolHandler) {
+              waitXcmData = {
+                targetAmount: data.data.amount,
+                chain: poolHandler.chain,
+                token: poolHandler.metadataInfo.inputAsset,
+                // TODO: Change this depends on pool
+                nextTxType: _KoniTypes.ExtrinsicType.JOIN_YIELD_POOL
+              };
+            }
+            submitData = async (step, callback) => {
+              const isPassConfirmation = !callback;
+              const onSend = callback
+              // eslint-disable-next-line node/no-callback-literal
+              ? rs => callback(rs) : undefined;
+              return this.handleYieldStep({
+                ...data,
+                currentStep: step,
+                isPassConfirmation,
+                onSend,
+                errorOnTimeOut: true,
+                processId
+              });
+            };
+            stepNums = data.path.steps.length;
+          } else {
+            const data = requestData;
+            stepNums = data.process.steps.length;
+            const inputAsset = this.#koniState.chainService.getAssetBySlug(data.quote.pair.from);
+            waitXcmData = {
+              targetAmount: data.quote.fromAmount,
+              chain: inputAsset.originChain,
+              token: inputAsset.slug,
+              nextTxType: _KoniTypes.ExtrinsicType.SWAP
+            };
+            submitData = async (step, callback) => {
+              const isLastStep = step === stepNums - 1;
+              const isPassConfirmation = !callback;
+              const onSend = callback
+              // eslint-disable-next-line node/no-callback-literal
+              ? rs => callback(rs) : undefined;
+              if (stepNums > 2 && isLastStep) {
+                const quote = data.quote;
+                const latestSwapQuote = await this.getLatestSwapQuote({
+                  address: data.address,
+                  currentQuote: quote.provider,
+                  feeToken: quote.feeInfo.selectedFeeToken,
+                  recipient: data.recipient,
+                  pair: quote.pair,
+                  fromAmount: quote.fromAmount,
+                  slippage: data.slippage
+                });
+                return this.handleSwapStep({
+                  ...data,
+                  quote: latestSwapQuote.optimalQuote || data.quote,
+                  currentStep: step,
+                  isPassConfirmation,
+                  errorOnTimeOut: true,
+                  processId
+                });
+              }
+              return this.handleSwapStep({
+                ...data,
+                currentStep: step,
+                isPassConfirmation,
+                onSend,
+                errorOnTimeOut: true,
+                processId
+              });
+            };
+          }
+          if (stepNums < 3) {
+            throw new Error('Not need to use this feature');
+          }
+          const loopSubmit = async (submitFunc, step, callback) => {
+            const isLastStep = step === stepNums - 1;
+            const rs = await submitFunc(step, callback);
+            if (isLastStep) {
+              return rs;
+            } else {
+              if (rs.errors.length || rs.warnings.length) {
+                return rs;
+              }
+              if (rs.extrinsicType === _KoniTypes.ExtrinsicType.TRANSFER_XCM) {
+                await new Promise(resolve => {
+                  setTimeout(resolve, 60 * 1000);
+                  if (waitXcmData) {
+                    let unsub = _util.noop;
+                    const onRs = rs => {
+                      var _waitXcmData;
+                      if ((0, _bignumber.default)(rs.value).gte((0, _bignumber.default)(((_waitXcmData = waitXcmData) === null || _waitXcmData === void 0 ? void 0 : _waitXcmData.targetAmount) || '0'))) {
+                        unsub();
+                        resolve();
+                      }
+                    };
+                    this.#koniState.balanceService.subscribeTransferableBalance(address, waitXcmData.chain, waitXcmData.token, waitXcmData.nextTxType, onRs).then(_ref67 => {
+                      let [_unsub, rs] = _ref67;
+                      unsub = _unsub;
+                      onRs(rs);
+                    }).catch(console.error);
+                  }
+                });
+              }
+              return loopSubmit(submitFunc, step + 1);
+            }
+          };
+          return new Promise((resolve, reject) => {
+            loopSubmit(submitData, currentStep, resolve).then(resolve).catch(reject);
+          });
+        }
+    }
+  }
+  createPassConfirmationParams() {
+    let pass = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    if (pass) {
+      return {
+        isPassConfirmation: true,
+        signAfterCreate: id => {
+          this.signingApprovePasswordV2({
+            id
+          }).catch(console.log);
+        }
+      };
+    } else {
+      return {
+        isPassConfirmation: false
+      };
+    }
+  }
+  async subscribeProcessById(request, id, port) {
+    const cb = (0, _subscriptions.createSubscription)(id, port);
+    const observable = this.#koniState.dbService.observableProcessTransactionById(request.processId);
+    const subscription = observable.subscribe(rs => {
+      // eslint-disable-next-line node/no-callback-literal
+      cb({
+        process: rs,
+        id
+      });
+    });
+    this.createUnsubscriptionHandle(id, subscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    return {
+      process: await this.#koniState.dbService.getProcessTransactionById(request.processId),
+      id
+    };
+  }
+  subscribeProcessAlive(id, port) {
+    const cb = (0, _subscriptions.createSubscription)(id, port);
+    const observable = this.#koniState.transactionService.observables.aliveProcess;
+    const convertData = rs => {
+      return {
+        processes: rs
+      };
+    };
+    const subscription = observable.subscribe(rs => {
+      cb(convertData(rs));
+    });
+    this.createUnsubscriptionHandle(id, subscription.unsubscribe);
+    port.onDisconnect.addListener(() => {
+      this.cancelSubscription(id);
+    });
+    const value = this.#koniState.transactionService.values.aliveProcess;
+    return convertData(value);
+  }
+
+  /* Multi process */
+
   // --------------------------------------------------------------
   // eslint-disable-next-line @typescript-eslint/require-await
   async handle(id, type, request, port) {
@@ -3768,6 +4186,8 @@ class KoniExtension {
         return this.setLanguage(request);
       case 'pri(settings.saveShowBalance)':
         return this.setShowBalance(request);
+      case 'pri(settings.update.allowOneSign)':
+        return this.setAllowOneSign(request);
       case 'pri(price.getPrice)':
         return await this.getPrice();
       case 'pri(price.getSubscription)':
@@ -4276,6 +4696,15 @@ class KoniExtension {
         return this.subscribePriorityTokens(id, port);
       /* Priority tokens */
 
+      /* Multi process */
+      case 'pri(process.transaction.submit)':
+        return this.handleSubmitProcessTransaction(request);
+      case 'pri(process.subscribe.id)':
+        return this.subscribeProcessById(request, id, port);
+      case 'pri(process.subscribe.alive)':
+        return this.subscribeProcessAlive(id, port);
+      /* Multi process */
+
       // Default
       default:
         throw new Error(`Unable to handle message of type ${type}`);