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

package/koni/background/handlers/Extension.js

@@ -40,8 +40,8 @@ import { checkLiquidityForPool, estimateTokensForPool, getReserveForPool } from
 import { isProposalExpired, isSupportWalletConnectChain, isSupportWalletConnectNamespace } from '@subwallet/extension-base/services/wallet-connect-service/helpers';
 import { SWStorage } from '@subwallet/extension-base/storage';
 import { AccountsStore } from '@subwallet/extension-base/stores';
-import { BasicTxErrorType, BasicTxWarningCode, StakingTxErrorType, YieldPoolType } from '@subwallet/extension-base/types';
-import { _analyzeAddress, calculateMaxTransferable, combineAllAccountProxy, createTransactionFromRLP, detectTransferTxType, isSameAddress, MODULE_SUPPORT, reformatAddress, signatureToHex, transformAccounts, transformAddresses, uniqueStringArray } from '@subwallet/extension-base/utils';
+import { AccountSignMode, BasicTxErrorType, BasicTxWarningCode, CommonStepType, EarningProcessType, ProcessType, StakingTxErrorType, StepStatus, SwapFeeType, SwapStepType, YieldPoolType, YieldStepType } from '@subwallet/extension-base/types';
+import { _analyzeAddress, calculateMaxTransferable, combineAllAccountProxy, createTransactionFromRLP, detectTransferTxType, getAccountSignMode, isSameAddress, MODULE_SUPPORT, reformatAddress, signatureToHex, transformAccounts, transformAddresses, uniqueStringArray } from '@subwallet/extension-base/utils';
 import { parseContractInput, parseEvmRlp } from '@subwallet/extension-base/utils/eth/parseTransaction';
 import { getId } from '@subwallet/extension-base/utils/getId';
 import { getKeypairTypeByAddress, isAddress, isSubstrateAddress, isTonAddress } from '@subwallet/keyring';
@@ -799,6 +799,12 @@ export default class KoniExtension {
     this.#koniState.updateSetting('isShowBalance', enable);
     return true;
   }
+  setAllowOneSign({
+    allowOneSign
+  }) {
+    this.#koniState.updateSetting('allowOneSign', allowOneSign);
+    return true;
+  }
   async subscribeAuthUrls(id, port) {
     const cb = createSubscription(id, port);
     const authorizeUrlSubscription = this.#koniState.subscribeAuthorizeUrlSubject().subscribe({
@@ -1290,6 +1296,7 @@ export default class KoniExtension {
       feeCustom,
       feeOption,
       from,
+      isPassConfirmation,
       nonNativeTokenPayFeeSlug,
       originNetworkKey,
       to,
@@ -1413,6 +1420,7 @@ export default class KoniExtension {
       nonNativeTokenPayFeeSlug,
       isTransferAll: transferAll,
       isTransferLocalTokenAndPayThatTokenAsFee,
+      isPassConfirmation,
       errors,
       additionalValidator: additionalValidator,
       eventsHandler: eventsHandler
@@ -2577,28 +2585,44 @@ export default class KoniExtension {
     } = this.#koniState.transactionService.getTransaction(id);
     return transactionResult;
   }
-  subscribeTransactions(id, port) {
+  async subscribeTransactions(id, port) {
     const cb = createSubscription(id, port);
-    function convertRs(rs) {
+    function convertRs(rs, processMap) {
       return Object.fromEntries(Object.entries(rs).map(([key, value]) => {
         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 = combineLatest({
+      transactions: transactionsObservable,
+      processMap: processTransactionObservable
+    }).subscribe(({
+      processMap,
+      transactions
+    }) => {
+      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 = createSubscription(id, port);
@@ -3046,12 +3070,29 @@ export default 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: StepStatus.FAILED
+        });
+      }
       return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new TransactionError(BasicTxErrorType.INTERNAL_ERROR)]);
     }
     const isLastStep = inputData.currentStep + 1 === path.steps.length;
@@ -3061,6 +3102,11 @@ export default class KoniExtension {
     }); // TODO: validate, set to fail upon submission
 
     if (yieldValidation.length > 0) {
+      if (step) {
+        this.#koniState.transactionService.updateProcessStepStatus(step, {
+          status: StepStatus.FAILED
+        });
+      }
       return this.#koniState.transactionService.generateBeforeHandleResponseErrors(yieldValidation);
     }
 
@@ -3074,7 +3120,66 @@ export default 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 = 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: 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 === YieldStepType.JOIN_NOMINATION_POOL ? EarningProcessType.NOMINATION_POOL : lastStep.type === YieldStepType.NOMINATE ? EarningProcessType.NATIVE_STAKING : 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: reformatAddress(address),
+          type: ProcessType.EARNING,
+          combineInfo,
+          currentStepId: step.stepId,
+          steps: path.steps.map((step, index) => {
+            const fee = convertFee(path.totalFee[index]);
+            if (![YieldStepType.XCM, YieldStepType.DEFAULT, YieldStepType.TOKEN_APPROVAL].includes(step.type)) {
+              const metadata = data;
+              return {
+                ...step,
+                status: StepStatus.QUEUED,
+                fee,
+                metadata: metadata
+              };
+            }
+            return {
+              ...step,
+              fee,
+              status: StepStatus.QUEUED
+            };
+          }).filter(step => step.type !== YieldStepType.DEFAULT),
+          status: StepStatus.QUEUED
+        });
+      }
+    }
     return await this.#koniState.transactionService.handleTransaction({
       address,
       chain: txChain,
@@ -3086,7 +3191,11 @@ export default class KoniExtension {
       chainType,
       resolveOnDone: !isLastStep,
       transferNativeAmount,
-      skipFeeValidation: isMintingStep && isPoolSupportAlternativeFee
+      skipFeeValidation: isMintingStep && isPoolSupportAlternativeFee,
+      errorOnTimeOut,
+      ...this.createPassConfirmationParams(isPassConfirmation),
+      eventsHandler,
+      step
     });
   }
   async handleYieldLeave(params) {
@@ -3430,11 +3539,28 @@ export default 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: StepStatus.FAILED
+        });
+      }
       return this.#koniState.transactionService.generateBeforeHandleResponseErrors([new TransactionError(BasicTxErrorType.INTERNAL_ERROR)]);
     }
     const isLastStep = inputData.currentStep + 1 === process.steps.length;
@@ -3445,6 +3571,11 @@ export default class KoniExtension {
       recipient
     });
     if (swapValidations.length > 0) {
+      if (step) {
+        this.#koniState.transactionService.updateProcessStepStatus(step, {
+          status: StepStatus.FAILED
+        });
+      }
       return this.#koniState.transactionService.generateBeforeHandleResponseErrors(swapValidations);
     }
 
@@ -3460,6 +3591,85 @@ export default 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: reformatAddress(address),
+          type: ProcessType.SWAP,
+          currentStepId: step.stepId,
+          combineInfo,
+          steps: inputData.process.steps.map((step, index) => {
+            const fee = inputData.process.totalFee[index];
+            if (step.type === 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: StepStatus.QUEUED,
+                fee,
+                metadata: metadata
+              };
+            }
+            return {
+              ...step,
+              fee,
+              status: StepStatus.QUEUED
+            };
+          }).filter(step => step.type !== CommonStepType.DEFAULT),
+          status: 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 ? StepStatus.PREPARE : 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,
@@ -3470,7 +3680,11 @@ export default class KoniExtension {
       // change this depends on step
       chainType,
       resolveOnDone: !isLastStep,
-      transferNativeAmount
+      transferNativeAmount,
+      ...this.createPassConfirmationParams(isPassConfirmation),
+      errorOnTimeOut,
+      eventsHandler,
+      step
       // skipFeeValidation: chosenFeeToken && allowSkipValidation
     });
   }
@@ -3599,6 +3813,206 @@ export default class KoniExtension {
 
   /* Popular tokens */
 
+  /* Multi process */
+
+  async handleSubmitProcessTransaction(_request) {
+    const {
+      address,
+      id: processId,
+      request: requestData,
+      type
+    } = _request;
+    const pair = keyring.getPair(address);
+    if (!pair) {
+      throw new Error('Pair not found');
+    }
+    const signMode = getAccountSignMode(address, pair.meta);
+    if (signMode !== 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 ProcessType.EARNING:
+
+      // eslint-disable-next-line no-fallthrough
+      case ProcessType.SWAP:
+        {
+          const currentStep = requestData.currentStep;
+          let stepNums;
+          let submitData;
+          let waitXcmData;
+          if (type === 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: 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: 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 === ExtrinsicType.TRANSFER_XCM) {
+                await new Promise(resolve => {
+                  setTimeout(resolve, 60 * 1000);
+                  if (waitXcmData) {
+                    let unsub = noop;
+                    const onRs = rs => {
+                      var _waitXcmData;
+                      if (BigN(rs.value).gte(BigN(((_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(([_unsub, rs]) => {
+                      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(pass = 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 = 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 = 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) {
@@ -3690,6 +4104,8 @@ export default 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)':
@@ -4198,6 +4614,15 @@ export default 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}`);