@subwallet/extension-base 1.3.26-0 → 1.3.27-1

package/services/swap-service/handler/hydradx-handler.js

@@ -8,14 +8,16 @@ import { TransactionError } from '@subwallet/extension-base/background/errors/Tr
 import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { XCM_MIN_AMOUNT_RATIO } from '@subwallet/extension-base/constants';
 import { createXcmExtrinsic } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
-import { _getAssetDecimals, _getChainNativeTokenSlug, _getTokenOnChainAssetId, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getChainNativeTokenSlug, _getTokenMinAmount, _getTokenOnChainAssetId, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
 import { SwapBaseHandler } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
-import { getSwapAlternativeAsset } from '@subwallet/extension-base/services/swap-service/utils';
+import { DynamicSwapType } from '@subwallet/extension-base/services/swap-service/interface';
+import { FEE_RATE_MULTIPLIER, getSwapAlternativeAsset } from '@subwallet/extension-base/services/swap-service/utils';
 import { BasicTxErrorType } from '@subwallet/extension-base/types';
 import { CommonStepType } from '@subwallet/extension-base/types/service-base';
 import { SwapErrorType, SwapFeeType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types/swap';
 import { getId } from '@subwallet/extension-base/utils/getId';
 import BigNumber from 'bignumber.js';
+import { isHex } from '@polkadot/util';
 const HYDRADX_SUBWALLET_REFERRAL_CODE = 'WALLET';
 const HYDRADX_SUBWALLET_REFERRAL_ACCOUNT = '7PCsCpkgsHdNaZhv79wCCQ5z97uxVbSeSCtDMUa1eZHKXy4a';
 const HYDRADX_TESTNET_SUBWALLET_REFERRAL_CODE = 'ASSETHUB';
@@ -187,35 +189,138 @@ export class HydradxHandler {
     }
     return Promise.resolve(undefined);
   }
+  async getXcmStepV2(params) {
+    var _params$path$find;
+    // todo: improve this function for Round 2
+
+    const xcmPairInfo = (_params$path$find = params.path.find((step, i) => i === 0 && step.action === DynamicSwapType.BRIDGE)) === null || _params$path$find === void 0 ? void 0 : _params$path$find.pair;
+    if (!xcmPairInfo) {
+      return undefined;
+    }
+    const fromTokenInfo = this.chainService.getAssetBySlug(xcmPairInfo.from);
+    const toTokenInfo = this.chainService.getAssetBySlug(xcmPairInfo.to);
+    const fromChainInfo = this.chainService.getChainInfoByKey(fromTokenInfo.originChain);
+    const toChainInfo = this.chainService.getChainInfoByKey(toTokenInfo.originChain);
+    if (!fromChainInfo || !toChainInfo || !fromChainInfo || !toChainInfo) {
+      throw Error('Token and chain not found');
+    }
+    try {
+      const substrateApi = await this.chainService.getSubstrateApi(fromTokenInfo.originChain).isReady;
+      const id = getId();
+      const [feeInfo, toTokenBalance] = await Promise.all([this.swapBaseHandler.feeService.subscribeChainFee(id, fromTokenInfo.originChain, 'substrate'), this.balanceService.getTotalBalance(params.request.address, toTokenInfo.originChain, toTokenInfo.slug, ExtrinsicType.TRANSFER_BALANCE)]);
+      const xcmTransfer = await createXcmExtrinsic({
+        originTokenInfo: fromTokenInfo,
+        destinationTokenInfo: toTokenInfo,
+        // Mock sending value to get payment info
+        sendingValue: params.request.fromAmount,
+        recipient: params.request.address,
+        substrateApi: substrateApi,
+        sender: params.request.address,
+        originChain: fromChainInfo,
+        destinationChain: toChainInfo,
+        feeInfo
+      });
+      const _xcmFeeInfo = await xcmTransfer.paymentInfo(params.request.address);
+      const xcmFeeInfo = _xcmFeeInfo.toPrimitive();
+      const fee = {
+        feeComponent: [{
+          feeType: SwapFeeType.NETWORK_FEE,
+          amount: Math.ceil(xcmFeeInfo.partialFee * FEE_RATE_MULTIPLIER.high).toString(),
+          tokenSlug: _getChainNativeTokenSlug(fromChainInfo)
+        }],
+        defaultFeeToken: _getChainNativeTokenSlug(fromChainInfo),
+        feeOptions: [_getChainNativeTokenSlug(fromChainInfo)]
+      };
+      let bnTransferAmount = new BigNumber(params.request.fromAmount);
+
+      // todo: increase transfer amount when XCM local token
+      if (_isNativeToken(fromTokenInfo)) {
+        // xcm fee is paid in native token but swap token is not always native token
+        // add amount of fee into sending value to ensure has enough token to swap
+        const bnXcmFee = new BigNumber(fee.feeComponent[0].amount);
+        bnTransferAmount = bnTransferAmount.plus(bnXcmFee);
+      } else {
+        bnTransferAmount = bnTransferAmount.plus(BigNumber(_getTokenMinAmount(toTokenInfo)).multipliedBy(FEE_RATE_MULTIPLIER.medium));
+      }
+      if (BigNumber(toTokenBalance.value).lte(0)) {
+        bnTransferAmount = bnTransferAmount.plus(_getTokenMinAmount(toTokenInfo));
+      }
+      const step = {
+        metadata: {
+          sendingValue: bnTransferAmount.toString(),
+          originTokenInfo: fromTokenInfo,
+          destinationTokenInfo: toTokenInfo
+        },
+        name: `Transfer ${fromTokenInfo.symbol} from ${fromChainInfo.name}`,
+        type: CommonStepType.XCM
+      };
+      return [step, fee];
+    } catch (e) {
+      console.error('Error creating xcm step', e);
+      return undefined;
+    }
+  }
+  async getSwapStepV2(params) {
+    var _params$path$find2;
+    const swapPairInfo = (_params$path$find2 = params.path.find(step => step.action === DynamicSwapType.SWAP)) === null || _params$path$find2 === void 0 ? void 0 : _params$path$find2.pair;
+    if (!swapPairInfo) {
+      return Promise.resolve(undefined);
+    }
+    if (!params.selectedQuote) {
+      return Promise.resolve(undefined);
+    }
+    const txHex = params.selectedQuote.metadata;
+    if (!txHex || !isHex(txHex)) {
+      return Promise.resolve(undefined);
+    }
+    const metadata = {
+      sendingValue: params.request.fromAmount.toString(),
+      originTokenInfo: this.chainService.getAssetBySlug(swapPairInfo.from),
+      destinationTokenInfo: this.chainService.getAssetBySlug(swapPairInfo.to),
+      txHex
+    };
+    const submitStep = {
+      name: 'Swap',
+      type: SwapStepType.SWAP,
+      // @ts-ignore
+      metadata
+    };
+    return Promise.resolve([submitStep, params.selectedQuote.feeInfo]); // review fee
+  }
+
   generateOptimalProcess(params) {
     return this.swapBaseHandler.generateOptimalProcess(params, [this.getXcmStep.bind(this),
     // this.getFeeOptionStep.bind(this),
     this.getSubmitStep.bind(this)]);
   }
+  generateOptimalProcessV2(params) {
+    const stepFuncList = params.path.map(step => {
+      if (step.action === DynamicSwapType.BRIDGE) {
+        return this.getXcmStepV2.bind(this);
+      }
+      if (step.action === DynamicSwapType.SWAP) {
+        return this.getSwapStepV2.bind(this);
+      }
+      throw new Error(`Error generating optimal process: Action ${step.action} is not supported`);
+    });
+    return this.swapBaseHandler.generateOptimalProcessV2(params, stepFuncList);
+  }
   async handleXcmStep(params) {
-    const pair = params.quote.pair;
-    const alternativeAssetSlug = getSwapAlternativeAsset(pair);
-    const originAsset = this.chainService.getAssetBySlug(alternativeAssetSlug);
-    const destinationAsset = this.chainService.getAssetBySlug(pair.from);
+    const briefXcmStep = params.process.steps[params.currentStep].metadata;
+    if (!briefXcmStep || !briefXcmStep.originTokenInfo || !briefXcmStep.destinationTokenInfo || !briefXcmStep.sendingValue) {
+      throw new Error('XCM metadata error');
+    }
+    const originAsset = briefXcmStep.originTokenInfo;
+    const destinationAsset = briefXcmStep.destinationTokenInfo;
     const originChain = this.chainService.getChainInfoByKey(originAsset.originChain);
     const destinationChain = this.chainService.getChainInfoByKey(destinationAsset.originChain);
     const substrateApi = this.chainService.getSubstrateApi(originAsset.originChain);
     const chainApi = await substrateApi.isReady;
-    const destinationAssetBalance = await this.balanceService.getTransferableBalance(params.address, destinationAsset.originChain, destinationAsset.slug);
-    const xcmFee = params.process.totalFee[params.currentStep];
-    const bnAmount = new BigNumber(params.quote.fromAmount);
-    const bnDestinationAssetBalance = new BigNumber(destinationAssetBalance.value);
-    let bnTotalAmount = bnAmount.minus(bnDestinationAssetBalance);
-    if (_isNativeToken(originAsset)) {
-      const bnXcmFee = new BigNumber(xcmFee.feeComponent[0].amount); // xcm fee is paid in native token but swap token is not always native token
-
-      bnTotalAmount = bnTotalAmount.plus(bnXcmFee);
-    }
     const feeInfo = await this.swapBaseHandler.feeService.subscribeChainFee(getId(), originAsset.originChain, 'substrate');
     const xcmTransfer = await createXcmExtrinsic({
       originTokenInfo: originAsset,
       destinationTokenInfo: destinationAsset,
-      sendingValue: bnTotalAmount.toString(),
+      sendingValue: briefXcmStep.sendingValue,
       recipient: params.address,
       substrateApi: chainApi,
       sender: params.address,
@@ -228,14 +333,14 @@ export class HydradxHandler {
       destinationNetworkKey: destinationAsset.originChain,
       from: params.address,
       to: params.address,
-      value: bnTotalAmount.toString(),
+      value: briefXcmStep.sendingValue,
       tokenSlug: originAsset.slug,
       showExtraWarning: true
     };
     return {
       txChain: originAsset.originChain,
       extrinsic: xcmTransfer,
-      transferNativeAmount: _isNativeToken(originAsset) ? bnTotalAmount.toString() : '0',
+      transferNativeAmount: _isNativeToken(originAsset) ? briefXcmStep.sendingValue : '0',
       extrinsicType: ExtrinsicType.TRANSFER_XCM,
       chainType: ChainType.SUBSTRATE,
       txData: xcmData
@@ -266,18 +371,18 @@ export class HydradxHandler {
     };
   }
   async handleSubmitStep(params) {
-    const fromAsset = this.chainService.getAssetBySlug(params.quote.pair.from);
-    const toAsset = this.chainService.getAssetBySlug(params.quote.pair.to);
-    const fromAssetId = _getTokenOnChainAssetId(fromAsset);
-    const toAssetId = _getTokenOnChainAssetId(toAsset);
+    const metadata = params.process.steps[params.currentStep].metadata;
+    const txHex = params.quote.metadata;
+    if (!txHex || !isHex(txHex)) {
+      return new SwapError(SwapErrorType.UNKNOWN);
+    }
+    if (!metadata || !metadata.sendingValue || !metadata.txHex || !metadata.destinationTokenInfo || !metadata.originTokenInfo) {
+      throw new Error('Swap metadata error');
+    }
+    const fromAsset = metadata.originTokenInfo;
     if (!this.isReady || !this.tradeRouter) {
       return new SwapError(SwapErrorType.UNKNOWN);
     }
-    const parsedFromAmount = new BigNumber(params.quote.fromAmount).shiftedBy(-1 * _getAssetDecimals(fromAsset)).toString();
-    const quoteResponse = await this.tradeRouter.getBestSell(fromAssetId, toAssetId, parsedFromAmount);
-    const toAmount = quoteResponse.amountOut;
-    const minReceive = toAmount.times(1 - params.slippage).integerValue();
-    const txHex = quoteResponse.toTx(minReceive).hex;
     const substrateApi = this.chainService.getSubstrateApi(this.chain());
     const chainApi = await substrateApi.isReady;
     const txData = {
@@ -285,7 +390,7 @@ export class HydradxHandler {
       quote: params.quote,
       address: params.address,
       slippage: params.slippage,
-      txHex,
+      txHex: txHex,
       process: params.process
     };
     let extrinsic;
@@ -313,8 +418,7 @@ export class HydradxHandler {
       txChain: fromAsset.originChain,
       txData,
       extrinsic,
-      transferNativeAmount: _isNativeToken(fromAsset) ? params.quote.fromAmount : '0',
-      // todo
+      transferNativeAmount: _isNativeToken(fromAsset) ? metadata.sendingValue : '0',
       extrinsicType: ExtrinsicType.SWAP,
       chainType: ChainType.SUBSTRATE
     };
@@ -344,14 +448,22 @@ export class HydradxHandler {
     if (bnAmount.lte(0)) {
       return [new TransactionError(BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
     }
+    const swapStep = params.process.steps.find(item => item.type === SwapStepType.SWAP);
+    if (!swapStep) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR, 'Swap step not found')];
+    }
     let isXcmOk = false;
+    const currentStep = params.currentStep;
     for (const [index, step] of params.process.steps.entries()) {
+      if (currentStep > index) {
+        continue;
+      }
       const getErrors = async () => {
         switch (step.type) {
           case CommonStepType.DEFAULT:
             return Promise.resolve([]);
           case CommonStepType.XCM:
-            return this.swapBaseHandler.validateXcmStep(params, index);
+            return this.swapBaseHandler.validateXcmStepV2(params, index);
           case CommonStepType.SET_FEE_TOKEN:
             return this.swapBaseHandler.validateSetFeeTokenStep(params, index);
           default:
@@ -367,6 +479,38 @@ export class HydradxHandler {
     }
     return [];
   }
+  async validateSwapProcessV2(params) {
+    // todo: recheck address and recipient format in params
+    const {
+      process,
+      selectedQuote
+    } = params; // todo: review flow, currentStep param.
+
+    // todo: validate path with optimalProcess
+    // todo: review error message in case many step swap
+    if (BigNumber(selectedQuote.fromAmount).lte(0)) {
+      return [new TransactionError(BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
+    }
+    const actionList = JSON.stringify(process.path.map(step => step.action));
+    const swap = actionList === JSON.stringify([DynamicSwapType.SWAP]);
+    const swapXcm = actionList === JSON.stringify([DynamicSwapType.SWAP, DynamicSwapType.BRIDGE]);
+    const xcmSwap = actionList === JSON.stringify([DynamicSwapType.BRIDGE, DynamicSwapType.SWAP]);
+    const xcmSwapXcm = actionList === JSON.stringify([DynamicSwapType.BRIDGE, DynamicSwapType.SWAP, DynamicSwapType.BRIDGE]);
+    if (swap) {
+      return this.swapBaseHandler.validateSwapOnlyProcess(params, 1); // todo: create interface for input request
+    }
+
+    if (swapXcm) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwap) {
+      return this.swapBaseHandler.validateXcmSwapProcess(params, 2, 1);
+    }
+    if (xcmSwapXcm) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+  }
   get referralCode() {
     if (this.isTestnet) {
       return HYDRADX_TESTNET_SUBWALLET_REFERRAL_CODE;

package/services/swap-service/handler/simpleswap-handler.d.ts

@@ -1,6 +1,6 @@
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import FeeService from '@subwallet/extension-base/services/fee-service/service';
-import { BaseStepDetail, CommonOptimalPath, CommonStepFeeInfo, OptimalSwapPathParams, SwapProviderId, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types';
+import { BaseStepDetail, CommonOptimalSwapPath, CommonStepFeeInfo, OptimalSwapPathParams, OptimalSwapPathParamsV2, SwapProviderId, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types';
 import { BalanceService } from '../../balance-service';
 import { ChainService } from '../../chain-service';
 import { SwapBaseInterface } from './base-handler';
@@ -15,8 +15,10 @@ export declare class SimpleSwapHandler implements SwapBaseInterface {
     get providerInfo(): import("@subwallet/extension-base/types").SwapProvider;
     get name(): string;
     get slug(): string;
-    generateOptimalProcess(params: OptimalSwapPathParams): Promise<CommonOptimalPath>;
+    generateOptimalProcess(params: OptimalSwapPathParams): Promise<CommonOptimalSwapPath>;
+    generateOptimalProcessV2(params: OptimalSwapPathParamsV2): Promise<CommonOptimalSwapPath>;
     getSubmitStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
     handleSwapProcess(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     handleSubmitStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+    validateSwapProcessV2(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
 }

package/services/swap-service/handler/simpleswap-handler.js

@@ -5,6 +5,7 @@ import { SwapError } from '@subwallet/extension-base/background/errors/SwapError
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { _getAssetDecimals, _getContractAddressOfToken, _isChainSubstrateCompatible, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { DynamicSwapType } from '@subwallet/extension-base/services/swap-service/interface';
 import { BasicTxErrorType, CommonStepType, SwapErrorType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types';
 import { _reformatAddressWithChain, formatNumber } from '@subwallet/extension-base/utils';
 import { getId } from '@subwallet/extension-base/utils/getId';
@@ -105,11 +106,19 @@ export class SimpleSwapHandler {
   generateOptimalProcess(params) {
     return this.swapBaseHandler.generateOptimalProcess(params, [this.getSubmitStep.bind(this)]);
   }
+  generateOptimalProcessV2(params) {
+    return this.swapBaseHandler.generateOptimalProcessV2(params, [this.getSubmitStep.bind(this)]);
+  }
   async getSubmitStep(params) {
     if (params.selectedQuote) {
       const submitStep = {
         name: 'Swap',
-        type: SwapStepType.SWAP
+        type: SwapStepType.SWAP,
+        metadata: {
+          sendingValue: params.request.fromAmount.toString(),
+          originTokenInfo: this.chainService.getAssetBySlug(params.selectedQuote.pair.from),
+          destinationTokenInfo: this.chainService.getAssetBySlug(params.selectedQuote.pair.to)
+        }
       };
       return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
     }
@@ -162,6 +171,9 @@ export class SimpleSwapHandler {
       sender,
       toAsset
     });
+    if (!id || id.length === 0 || !addressFrom || addressFrom.length === 0) {
+      throw new SwapError(SwapErrorType.UNKNOWN);
+    }
 
     // Validate the amount to be swapped
     const rate = BigN(amountTo).div(BigN(quote.toAmount)).multipliedBy(100);
@@ -230,4 +242,41 @@ export class SimpleSwapHandler {
       chainType
     };
   }
+  async validateSwapProcessV2(params) {
+    // todo: recheck address and recipient format in params
+    const {
+      process,
+      selectedQuote
+    } = params; // todo: review flow, currentStep param.
+
+    // todo: validate path with optimalProcess
+    // todo: review error message in case many step swap
+    if (BigNumber(selectedQuote.fromAmount).lte(0)) {
+      return [new TransactionError(BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
+    }
+    const actionList = JSON.stringify(process.path.map(step => step.action));
+    const swap = actionList === JSON.stringify([DynamicSwapType.SWAP]);
+    const swapXcm = actionList === JSON.stringify([DynamicSwapType.SWAP, DynamicSwapType.BRIDGE]);
+    const xcmSwap = actionList === JSON.stringify([DynamicSwapType.BRIDGE, DynamicSwapType.SWAP]);
+    const xcmSwapXcm = actionList === JSON.stringify([DynamicSwapType.BRIDGE, DynamicSwapType.SWAP, DynamicSwapType.BRIDGE]);
+    const swapIndex = params.process.steps.findIndex(step => step.type === SwapStepType.SWAP); // todo
+
+    if (swapIndex <= -1) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (swap) {
+      return this.swapBaseHandler.validateSwapOnlyProcess(params, swapIndex); // todo: create interface for input request
+    }
+
+    if (swapXcm) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwap) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwapXcm) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+  }
 }

package/services/swap-service/handler/uniswap-handler.d.ts

@@ -1,7 +1,7 @@
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import TransactionService from '@subwallet/extension-base/services/transaction-service';
-import { BaseStepDetail, CommonOptimalPath, CommonStepFeeInfo, OptimalSwapPathParams, PermitSwapData, SwapProviderId, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types';
+import { BaseStepDetail, CommonOptimalSwapPath, CommonStepFeeInfo, OptimalSwapPathParams, OptimalSwapPathParamsV2, PermitSwapData, SwapProviderId, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types';
 import { TransactionConfig } from 'web3-core';
 import { BalanceService } from '../../balance-service';
 import { ChainService } from '../../chain-service';
@@ -21,7 +21,8 @@ export declare class UniswapHandler implements SwapBaseInterface {
     get balanceService(): BalanceService;
     get feeService(): FeeService;
     get providerInfo(): import("@subwallet/extension-base/types").SwapProvider;
-    generateOptimalProcess(params: OptimalSwapPathParams): Promise<CommonOptimalPath>;
+    generateOptimalProcess(params: OptimalSwapPathParams): Promise<CommonOptimalSwapPath>;
+    generateOptimalProcessV2(params: OptimalSwapPathParamsV2): Promise<CommonOptimalSwapPath>;
     getApprovalStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
     getPermitStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
     getSubmitStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
@@ -38,4 +39,5 @@ export declare class UniswapHandler implements SwapBaseInterface {
         chainType: ChainType;
         isPermit: boolean;
     };
+    validateSwapProcessV2(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
 }

package/services/swap-service/handler/uniswap-handler.js

@@ -4,6 +4,7 @@
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { validateTypedSignMessageDataV3V4 } from '@subwallet/extension-base/core/logic-validation';
+import { DynamicSwapType } from '@subwallet/extension-base/services/swap-service/interface';
 import { BasicTxErrorType, CommonStepType, FeeOptionKey, SwapFeeType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types';
 import BigNumber from 'bignumber.js';
 import { _getContractAddressOfToken, _isNativeToken } from "../../chain-service/utils/index.js";
@@ -60,6 +61,9 @@ export class UniswapHandler {
   generateOptimalProcess(params) {
     return this.swapBaseHandler.generateOptimalProcess(params, [this.getApprovalStep.bind(this), this.getPermitStep.bind(this), this.getSubmitStep.bind(this)]);
   }
+  generateOptimalProcessV2(params) {
+    return this.swapBaseHandler.generateOptimalProcessV2(params, [this.getApprovalStep.bind(this), this.getPermitStep.bind(this), this.getSubmitStep.bind(this)]);
+  }
   async getApprovalStep(params) {
     if (params.selectedQuote) {
       const walletAddress = params.request.address;
@@ -118,7 +122,12 @@ export class UniswapHandler {
     if (params.selectedQuote) {
       const submitStep = {
         name: 'Swap',
-        type: SwapStepType.SWAP
+        type: SwapStepType.SWAP,
+        metadata: {
+          sendingValue: params.request.fromAmount.toString(),
+          originTokenInfo: this.chainService.getAssetBySlug(params.selectedQuote.pair.from),
+          destinationTokenInfo: this.chainService.getAssetBySlug(params.selectedQuote.pair.to)
+        }
       };
       return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
     }
@@ -320,4 +329,41 @@ export class UniswapHandler {
       isPermit: true
     };
   }
+  async validateSwapProcessV2(params) {
+    // todo: recheck address and recipient format in params
+    const {
+      process,
+      selectedQuote
+    } = params; // todo: review flow, currentStep param.
+
+    // todo: validate path with optimalProcess
+    // todo: review error message in case many step swap
+    if (BigNumber(selectedQuote.fromAmount).lte(0)) {
+      return [new TransactionError(BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
+    }
+    const actionList = JSON.stringify(process.path.map(step => step.action));
+    const swap = actionList === JSON.stringify([DynamicSwapType.SWAP]);
+    const swapXcm = actionList === JSON.stringify([DynamicSwapType.SWAP, DynamicSwapType.BRIDGE]);
+    const xcmSwap = actionList === JSON.stringify([DynamicSwapType.BRIDGE, DynamicSwapType.SWAP]);
+    const xcmSwapXcm = actionList === JSON.stringify([DynamicSwapType.BRIDGE, DynamicSwapType.SWAP, DynamicSwapType.BRIDGE]);
+    const swapIndex = params.process.steps.findIndex(step => step.type === SwapStepType.SWAP); // todo
+
+    if (swapIndex <= -1) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (swap) {
+      return this.swapBaseHandler.validateSwapOnlyProcess(params, swapIndex); // todo: create interface for input request
+    }
+
+    if (swapXcm) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwap) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwapXcm) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+  }
 }

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

@@ -1,8 +1,10 @@
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
 import { ServiceStatus, ServiceWithProcessInterface, StoppableServiceInterface } from '@subwallet/extension-base/services/base/types';
-import { CommonOptimalPath } from '@subwallet/extension-base/types/service-base';
-import { OptimalSwapPathParams, SwapPair, SwapProviderId, SwapQuoteResponse, SwapRequest, SwapRequestResult, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
+import { DynamicSwapAction } from '@subwallet/extension-base/services/swap-service/interface';
+import { OptimalSwapPathParamsV2, ValidateSwapProcessParams } from '@subwallet/extension-base/types';
+import { CommonOptimalSwapPath } from '@subwallet/extension-base/types/service-base';
+import { OptimalSwapPathParams, SwapPair, SwapProviderId, SwapQuoteResponse, SwapRequest, SwapRequestResult, SwapSubmitParams, SwapSubmitStepData } from '@subwallet/extension-base/types/swap';
 import { PromiseHandler } from '@subwallet/extension-base/utils';
 export declare const _isChainSupportedByProvider: (providerSlug: SwapProviderId, chain: string) => boolean;
 export declare class SwapService implements ServiceWithProcessInterface, StoppableServiceInterface {
@@ -17,9 +19,18 @@ export declare class SwapService implements ServiceWithProcessInterface, Stoppab
     constructor(state: KoniState);
     private askProvidersForQuote;
     private getDefaultProcess;
-    generateOptimalProcess(params: OptimalSwapPathParams): Promise<CommonOptimalPath>;
+    private getDefaultProcessV2;
+    generateOptimalProcess(params: OptimalSwapPathParams): Promise<CommonOptimalSwapPath>;
+    generateOptimalProcessV2(params: OptimalSwapPathParamsV2): Promise<CommonOptimalSwapPath>;
+    generateOptimalProcessWithoutPath(params: OptimalSwapPathParamsV2): Promise<CommonOptimalSwapPath>;
     handleSwapRequest(request: SwapRequest): Promise<SwapRequestResult>;
-    getLatestQuotes(request: SwapRequest): Promise<SwapQuoteResponse>;
+    handleSwapRequestV2(request: SwapRequest): Promise<SwapRequestResult>;
+    getAvailablePath(request: SwapRequest): [DynamicSwapAction[], SwapRequest | undefined];
+    getLatestQuoteFromSwapRequest(request: SwapRequest): Promise<{
+        path: DynamicSwapAction[];
+        swapQuoteResponse: SwapQuoteResponse;
+    }>;
+    private getLatestDirectQuotes;
     private initHandlers;
     init(): Promise<void>;
     start(): Promise<void>;
@@ -27,7 +38,6 @@ export declare class SwapService implements ServiceWithProcessInterface, Stoppab
     waitForStarted(): Promise<void>;
     waitForStopped(): Promise<void>;
     getSwapPairs(): SwapPair[];
-    private getSwapPairMetadata;
     validateSwapProcess(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
     handleSwapProcess(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     subscribeSwapPairs(callback: (pairs: SwapPair[]) => void): import("rxjs").Subscription;