@subwallet/extension-base 1.3.29-1 → 1.3.30-0

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

@@ -4,7 +4,7 @@ import { BalanceService } from '@subwallet/extension-base/services/balance-servi
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
 import FeeService from '@subwallet/extension-base/services/fee-service/service';
 import { SwapBaseInterface } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
-import { BaseStepDetail, CommonOptimalSwapPath, CommonStepFeeInfo, OptimalSwapPathParams, OptimalSwapPathParamsV2, SwapProviderId, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types';
+import { BaseStepDetail, CommonOptimalSwapPath, CommonStepFeeInfo, OptimalSwapPathParamsV2, SwapProviderId, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types';
 export declare const CHAINFLIP_BROKER_API: string;
 export declare class ChainflipSwapHandler implements SwapBaseInterface {
     private readonly isTestnet;
@@ -18,11 +18,9 @@ export declare class ChainflipSwapHandler implements SwapBaseInterface {
     get name(): string;
     get slug(): string;
     get intermediaryAssetSlug(): COMMON_ASSETS.USDC_ETHEREUM | COMMON_ASSETS.USDC_SEPOLIA;
-    validateSwapProcess(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
     handleSubmitStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     handleSwapProcess(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
-    getSubmitStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
-    generateOptimalProcess(params: OptimalSwapPathParams): Promise<CommonOptimalSwapPath>;
+    getSubmitStep(params: OptimalSwapPathParamsV2, stepIndex: number): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
     generateOptimalProcessV2(params: OptimalSwapPathParamsV2): Promise<CommonOptimalSwapPath>;
     validateSwapProcessV2(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
 }

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

@@ -8,9 +8,8 @@ import { getERC20TransactionObject, getEVMTransactionObject } from '@subwallet/e
 import { createSubstrateExtrinsic } from '@subwallet/extension-base/services/balance-service/transfer/token';
 import { _getAssetSymbol, _getContractAddressOfToken, _isChainSubstrateCompatible, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
 import { SwapBaseHandler } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
-import { DynamicSwapType } from '@subwallet/extension-base/services/swap-service/interface';
 import { getChainflipSwap } from '@subwallet/extension-base/services/swap-service/utils';
-import { BasicTxErrorType, CommonStepType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types';
+import { BasicTxErrorType, CommonStepType, DynamicSwapType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types';
 import { _reformatAddressWithChain } from '@subwallet/extension-base/utils';
 import { getId } from '@subwallet/extension-base/utils/getId';
 import BigNumber from 'bignumber.js';
@@ -52,33 +51,6 @@ export class ChainflipSwapHandler {
       return INTERMEDIARY_MAINNET_ASSET_SLUG;
     }
   }
-  async validateSwapProcess(params) {
-    const amount = params.selectedQuote.fromAmount;
-    const bnAmount = new BigNumber(amount);
-    if (bnAmount.lte(0)) {
-      return [new TransactionError(BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
-    }
-    let isXcmOk = false;
-    for (const [index, step] of params.process.steps.entries()) {
-      const getErrors = async () => {
-        switch (step.type) {
-          case CommonStepType.DEFAULT:
-            return Promise.resolve([]);
-          case CommonStepType.TOKEN_APPROVAL:
-            return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
-          default:
-            return this.swapBaseHandler.validateSwapStep(params, isXcmOk, index);
-        }
-      };
-      const errors = await getErrors();
-      if (errors.length) {
-        return errors;
-      } else if (step.type === CommonStepType.XCM) {
-        isXcmOk = true;
-      }
-    }
-    return [];
-  }
   async handleSubmitStep(params) {
     const {
       address,
@@ -97,7 +69,7 @@ export class ChainflipSwapHandler {
     const toAssetId = _getAssetSymbol(toAsset);
     const minReceive = new BigNumber(quote.rate).times(1 - slippage).toString();
     const processMetadata = params.process.steps[params.currentStep].metadata;
-    const quoteMetadata = params.quote.metadata;
+    const quoteMetadata = processMetadata;
     if (!processMetadata || !quoteMetadata) {
       throw new Error('Metadata for Chainflip not found');
     }
@@ -205,7 +177,7 @@ export class ChainflipSwapHandler {
         return this.handleSubmitStep(params);
     }
   }
-  async getSubmitStep(params) {
+  async getSubmitStep(params, stepIndex) {
     var _params$selectedQuote;
     const metadata = (_params$selectedQuote = params.selectedQuote) === null || _params$selectedQuote === void 0 ? void 0 : _params$selectedQuote.metadata;
     if (!params.selectedQuote) {
@@ -214,22 +186,28 @@ export class ChainflipSwapHandler {
     if (!metadata || !metadata.srcChain || !metadata.destChain) {
       return Promise.resolve(undefined);
     }
+    const originTokenInfo = this.chainService.getAssetBySlug(params.selectedQuote.pair.from);
+    const destinationTokenInfo = this.chainService.getAssetBySlug(params.selectedQuote.pair.to);
+    const originChain = this.chainService.getChainInfoByKey(originTokenInfo.originChain);
+    const destinationChain = this.chainService.getChainInfoByKey(destinationTokenInfo.originChain);
     const submitStep = {
       name: 'Swap',
       type: SwapStepType.SWAP,
+      // @ts-ignore
       metadata: {
         sendingValue: params.request.fromAmount.toString(),
-        originTokenInfo: this.chainService.getAssetBySlug(params.selectedQuote.pair.from),
-        destinationTokenInfo: this.chainService.getAssetBySlug(params.selectedQuote.pair.to),
+        expectedReceive: params.selectedQuote.toAmount,
+        originTokenInfo,
+        destinationTokenInfo,
+        sender: _reformatAddressWithChain(params.request.address, originChain),
+        receiver: _reformatAddressWithChain(params.request.recipient || params.request.address, destinationChain),
         srcChain: metadata.srcChain,
-        destChain: metadata.destChain
+        destChain: metadata.destChain,
+        version: 2
       }
     };
     return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
   }
-  generateOptimalProcess(params) {
-    return this.swapBaseHandler.generateOptimalProcess(params, [this.getSubmitStep.bind(this)]);
-  }
   generateOptimalProcessV2(params) {
     return this.swapBaseHandler.generateOptimalProcessV2(params, [this.getSubmitStep.bind(this)]);
   }

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

@@ -5,10 +5,9 @@ import FeeService from '@subwallet/extension-base/services/fee-service/service';
 import { SwapBaseInterface } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
 import { OptimalSwapPathParamsV2, ValidateSwapProcessParams } from '@subwallet/extension-base/types';
 import { BaseStepDetail, CommonOptimalSwapPath, CommonStepFeeInfo } from '@subwallet/extension-base/types/service-base';
-import { OptimalSwapPathParams, SwapProviderId, SwapSubmitParams, SwapSubmitStepData } from '@subwallet/extension-base/types/swap';
+import { SwapProviderId, SwapSubmitParams, SwapSubmitStepData } from '@subwallet/extension-base/types/swap';
 export declare class HydradxHandler implements SwapBaseInterface {
     private swapBaseHandler;
-    private tradeRouter;
     private readonly isTestnet;
     isReady: boolean;
     providerSlug: SwapProviderId;
@@ -20,18 +19,12 @@ export declare class HydradxHandler implements SwapBaseInterface {
     get providerInfo(): import("@subwallet/extension-base/types").SwapProvider;
     get name(): string;
     get slug(): string;
-    getXcmStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
-    getFeeOptionStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
-    getSubmitStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
-    getXcmStepV2(params: OptimalSwapPathParamsV2): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
-    getSwapStepV2(params: OptimalSwapPathParamsV2): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
-    generateOptimalProcess(params: OptimalSwapPathParams): Promise<CommonOptimalSwapPath>;
+    getFeeOptionStep(params: OptimalSwapPathParamsV2): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
+    getSubmitStep(params: OptimalSwapPathParamsV2, stepIndex: number): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
     generateOptimalProcessV2(params: OptimalSwapPathParamsV2): Promise<CommonOptimalSwapPath>;
-    handleXcmStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     handleSetFeeStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     handleSubmitStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     handleSwapProcess(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
-    validateSwapProcess(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
     validateSwapProcessV2(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
     get referralCode(): "WALLET" | "ASSETHUB";
     get referralAccount(): "7PCsCpkgsHdNaZhv79wCCQ5z97uxVbSeSCtDMUa1eZHKXy4a" | "7LCt6dFqtxzdKVB2648jWW9d85doiFfLSbZJDNAMVJNxh5rJ";

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

@@ -1,22 +1,19 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-import { PoolService, TradeRouter } from '@galacticcouncil/sdk';
 import { COMMON_CHAIN_SLUGS } from '@subwallet/chain-list';
 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 { XCM_MIN_AMOUNT_RATIO } from '@subwallet/extension-base/constants';
-import { createXcmExtrinsic } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
-import { _getChainNativeTokenSlug, _getTokenMinAmount, _getTokenOnChainAssetId, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getTokenOnChainAssetId, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
 import { SwapBaseHandler } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
-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 { DEFAULT_EXCESS_AMOUNT_WEIGHT } from '@subwallet/extension-base/services/swap-service/utils';
+import { BasicTxErrorType, DynamicSwapType } 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 { _reformatAddressWithChain } from '@subwallet/extension-base/utils';
+import subwalletApiSdk from '@subwallet/subwallet-api-sdk';
+import BigN from 'bignumber.js';
 import { isHex } from '@polkadot/util';
 const HYDRADX_SUBWALLET_REFERRAL_CODE = 'WALLET';
 const HYDRADX_SUBWALLET_REFERRAL_ACCOUNT = '7PCsCpkgsHdNaZhv79wCCQ5z97uxVbSeSCtDMUa1eZHKXy4a';
@@ -41,10 +38,6 @@ export class HydradxHandler {
     if (!chainState.active) {
       await this.chainService.enableChain(this.chain());
     }
-    const substrateApi = this.chainService.getSubstrateApi(this.chain());
-    await substrateApi.api.isReady;
-    const poolService = new PoolService(substrateApi.api);
-    this.tradeRouter = new TradeRouter(poolService);
     this.isReady = true;
   }
   chain = () => {
@@ -70,75 +63,6 @@ export class HydradxHandler {
   get slug() {
     return this.swapBaseHandler.slug;
   }
-  async getXcmStep(params) {
-    const bnAmount = new BigNumber(params.request.fromAmount);
-    const fromAsset = this.chainService.getAssetBySlug(params.request.pair.from);
-    const fromAssetBalance = await this.balanceService.getTransferableBalance(params.request.address, fromAsset.originChain, fromAsset.slug);
-    const bnFromAssetBalance = new BigNumber(fromAssetBalance.value);
-    if (bnFromAssetBalance.gte(bnAmount)) {
-      return undefined; // enough balance, no need to xcm
-    }
-
-    const alternativeAssetSlug = getSwapAlternativeAsset(params.request.pair);
-    if (!alternativeAssetSlug) {
-      return undefined;
-    }
-    const alternativeAsset = this.chainService.getAssetBySlug(alternativeAssetSlug);
-    const alternativeAssetBalance = await this.balanceService.getTransferableBalance(params.request.address, alternativeAsset.originChain, alternativeAsset.slug);
-    const bnAlternativeAssetBalance = new BigNumber(alternativeAssetBalance.value);
-    if (bnAlternativeAssetBalance.lte(0)) {
-      return undefined;
-    }
-    try {
-      const alternativeChainInfo = this.chainService.getChainInfoByKey(alternativeAsset.originChain);
-      const destChainInfo = this.chainService.getChainInfoByKey(this.chain());
-      const xcmOriginSubstrateApi = await this.chainService.getSubstrateApi(alternativeAsset.originChain).isReady;
-      const id = getId();
-      const feeInfo = await this.swapBaseHandler.feeService.subscribeChainFee(id, alternativeAsset.originChain, 'substrate');
-      const xcmTransfer = await createXcmExtrinsic({
-        originTokenInfo: alternativeAsset,
-        destinationTokenInfo: fromAsset,
-        // Mock sending value to get payment info
-        sendingValue: bnAmount.toString(),
-        recipient: params.request.address,
-        substrateApi: xcmOriginSubstrateApi,
-        sender: params.request.address,
-        destinationChain: destChainInfo,
-        originChain: alternativeChainInfo,
-        feeInfo
-      });
-      const _xcmFeeInfo = await xcmTransfer.paymentInfo(params.request.address);
-      const xcmFeeInfo = _xcmFeeInfo.toPrimitive();
-      const fee = {
-        feeComponent: [{
-          feeType: SwapFeeType.NETWORK_FEE,
-          amount: Math.round(xcmFeeInfo.partialFee * XCM_MIN_AMOUNT_RATIO).toString(),
-          tokenSlug: _getChainNativeTokenSlug(alternativeChainInfo)
-        }],
-        defaultFeeToken: _getChainNativeTokenSlug(alternativeChainInfo),
-        feeOptions: [_getChainNativeTokenSlug(alternativeChainInfo)]
-      };
-      let bnTransferAmount = bnAmount.minus(bnFromAssetBalance);
-      if (_isNativeToken(alternativeAsset)) {
-        const bnXcmFee = new BigNumber(fee.feeComponent[0].amount); // xcm fee is paid in native token but swap token is not always native token
-
-        bnTransferAmount = bnTransferAmount.plus(bnXcmFee);
-      }
-      const step = {
-        metadata: {
-          sendingValue: bnTransferAmount.toString(),
-          originTokenInfo: alternativeAsset,
-          destinationTokenInfo: fromAsset
-        },
-        name: `Transfer ${alternativeAsset.symbol} from ${alternativeChainInfo.name}`,
-        type: CommonStepType.XCM
-      };
-      return [step, fee];
-    } catch (e) {
-      console.error('Error creating xcm step', e);
-      return undefined;
-    }
-  }
   async getFeeOptionStep(params) {
     if (!params.selectedQuote) {
       return Promise.resolve(undefined);
@@ -179,173 +103,94 @@ export class HydradxHandler {
       return undefined;
     }
   }
-  async getSubmitStep(params) {
-    if (params.selectedQuote) {
-      const submitStep = {
-        name: 'Swap',
-        type: SwapStepType.SWAP
-      };
-      return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
-    }
-    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 getSubmitStep(params, stepIndex) {
+    var _params$selectedQuote;
+    const {
+      path,
+      request: {
+        fromAmount
+      },
+      selectedQuote
+    } = params;
+    const stepData = path[stepIndex];
+    if (stepData.action !== DynamicSwapType.SWAP) {
+      return Promise.resolve(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) {
+    if (!selectedQuote) {
       return Promise.resolve(undefined);
     }
-    if (!params.selectedQuote) {
+    const swapPairInfo = stepData.pair;
+    if (!swapPairInfo || !selectedQuote) {
       return Promise.resolve(undefined);
     }
-    const txHex = params.selectedQuote.metadata;
+    const originTokenInfo = this.chainService.getAssetBySlug(swapPairInfo.from);
+    const destinationTokenInfo = this.chainService.getAssetBySlug(swapPairInfo.to);
+    const originChain = this.chainService.getChainInfoByKey(originTokenInfo.originChain);
+    const destinationChain = this.chainService.getChainInfoByKey(destinationTokenInfo.originChain);
+    const sender = _reformatAddressWithChain(params.request.address, originChain);
+    let receiver = _reformatAddressWithChain(params.request.recipient || params.request.address, destinationChain);
+    const actionList = JSON.stringify(path.map(step => step.action));
+    const xcmSwapXcm = actionList === JSON.stringify([DynamicSwapType.BRIDGE, DynamicSwapType.SWAP, DynamicSwapType.BRIDGE]);
+    const swapXcm = actionList === JSON.stringify([DynamicSwapType.SWAP, DynamicSwapType.BRIDGE]);
+    const needModifyData = swapXcm || xcmSwapXcm;
+    let txHex = (_params$selectedQuote = params.selectedQuote) === null || _params$selectedQuote === void 0 ? void 0 : _params$selectedQuote.metadata;
+    let bnSendingValue = BigN(fromAmount);
+    let bnExpectedReceive = BigN(selectedQuote.toAmount);
+    if (needModifyData) {
+      var _subwalletApiSdk$swap;
+      // override info if xcm-swap-xcm
+      bnSendingValue = bnSendingValue.multipliedBy(DEFAULT_EXCESS_AMOUNT_WEIGHT);
+      bnExpectedReceive = bnExpectedReceive.multipliedBy(DEFAULT_EXCESS_AMOUNT_WEIGHT);
+      const quotes = await ((_subwalletApiSdk$swap = subwalletApiSdk.swapApi) === null || _subwalletApiSdk$swap === void 0 ? void 0 : _subwalletApiSdk$swap.fetchSwapQuoteData({
+        address: sender,
+        pair: {
+          from: swapPairInfo.from,
+          to: swapPairInfo.to,
+          slug: swapPairInfo.slug
+        },
+        fromAmount: bnSendingValue.toFixed(0, 1),
+        slippage: params.request.slippage
+      }));
+      const quoteAskResponse = quotes === null || quotes === void 0 ? void 0 : quotes.find(quote => quote.provider === this.providerSlug);
+      if (!quoteAskResponse || !quoteAskResponse.quote) {
+        return Promise.resolve(undefined);
+      }
+      const overrideQuote = quoteAskResponse.quote;
+      txHex = overrideQuote.metadata;
+      receiver = _reformatAddressWithChain(params.request.address, destinationChain);
+    }
     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
+      metadata: {
+        sendingValue: bnSendingValue.toFixed(0, 1),
+        expectedReceive: bnExpectedReceive.toFixed(0, 1),
+        originTokenInfo,
+        destinationTokenInfo,
+        sender,
+        receiver,
+        txHex,
+        version: 2
+      }
     };
-    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)]);
+    return Promise.resolve([submitStep, selectedQuote.feeInfo]);
   }
   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);
+        return this.getSubmitStep.bind(this);
+      }
+      if (step.action === DynamicSwapType.BRIDGE) {
+        return this.swapBaseHandler.getBridgeStep.bind(this.swapBaseHandler);
       }
       throw new Error(`Error generating optimal process: Action ${step.action} is not supported`);
     });
     return this.swapBaseHandler.generateOptimalProcessV2(params, stepFuncList);
   }
-  async handleXcmStep(params) {
-    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 feeInfo = await this.swapBaseHandler.feeService.subscribeChainFee(getId(), originAsset.originChain, 'substrate');
-    const xcmTransfer = await createXcmExtrinsic({
-      originTokenInfo: originAsset,
-      destinationTokenInfo: destinationAsset,
-      sendingValue: briefXcmStep.sendingValue,
-      recipient: params.address,
-      substrateApi: chainApi,
-      sender: params.address,
-      destinationChain,
-      originChain,
-      feeInfo
-    });
-    const xcmData = {
-      originNetworkKey: originAsset.originChain,
-      destinationNetworkKey: destinationAsset.originChain,
-      from: params.address,
-      to: params.address,
-      value: briefXcmStep.sendingValue,
-      tokenSlug: originAsset.slug,
-      showExtraWarning: true
-    };
-    return {
-      txChain: originAsset.originChain,
-      extrinsic: xcmTransfer,
-      transferNativeAmount: _isNativeToken(originAsset) ? briefXcmStep.sendingValue : '0',
-      extrinsicType: ExtrinsicType.TRANSFER_XCM,
-      chainType: ChainType.SUBSTRATE,
-      txData: xcmData
-    };
-  }
   async handleSetFeeStep(params) {
     var _swapFeeInfo$selected;
     const substrateApi = this.chainService.getSubstrateApi(this.chain());
@@ -372,7 +217,7 @@ export class HydradxHandler {
   }
   async handleSubmitStep(params) {
     const metadata = params.process.steps[params.currentStep].metadata;
-    const txHex = params.quote.metadata;
+    const txHex = metadata.txHex;
     if (!txHex || !isHex(txHex)) {
       return new SwapError(SwapErrorType.UNKNOWN);
     }
@@ -380,7 +225,7 @@ export class HydradxHandler {
       throw new Error('Swap metadata error');
     }
     const fromAsset = metadata.originTokenInfo;
-    if (!this.isReady || !this.tradeRouter) {
+    if (!this.isReady) {
       return new SwapError(SwapErrorType.UNKNOWN);
     }
     const substrateApi = this.chainService.getSubstrateApi(this.chain());
@@ -433,7 +278,7 @@ export class HydradxHandler {
       case CommonStepType.DEFAULT:
         return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
       case CommonStepType.XCM:
-        return this.handleXcmStep(params);
+        return this.swapBaseHandler.handleBridgeStep(params);
       case CommonStepType.SET_FEE_TOKEN:
         return this.handleSetFeeStep(params);
       case SwapStepType.SWAP:
@@ -442,43 +287,6 @@ export class HydradxHandler {
         return this.handleSubmitStep(params);
     }
   }
-  async validateSwapProcess(params) {
-    const amount = params.selectedQuote.fromAmount;
-    const bnAmount = new BigNumber(amount);
-    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.validateXcmStepV2(params, index);
-          case CommonStepType.SET_FEE_TOKEN:
-            return this.swapBaseHandler.validateSetFeeTokenStep(params, index);
-          default:
-            return this.swapBaseHandler.validateSwapStep(params, isXcmOk, index);
-        }
-      };
-      const errors = await getErrors();
-      if (errors.length) {
-        return errors;
-      } else if (step.type === CommonStepType.XCM) {
-        isXcmOk = true;
-      }
-    }
-    return [];
-  }
   async validateSwapProcessV2(params) {
     // todo: recheck address and recipient format in params
     const {
@@ -488,7 +296,7 @@ export class HydradxHandler {
 
     // todo: validate path with optimalProcess
     // todo: review error message in case many step swap
-    if (BigNumber(selectedQuote.fromAmount).lte(0)) {
+    if (BigN(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));
@@ -501,13 +309,13 @@ export class HydradxHandler {
     }
 
     if (swapXcm) {
-      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+      return this.swapBaseHandler.validateSwapXcmProcess(params, 1, 2);
     }
     if (xcmSwap) {
       return this.swapBaseHandler.validateXcmSwapProcess(params, 2, 1);
     }
     if (xcmSwapXcm) {
-      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+      return this.swapBaseHandler.validateXcmSwapXcmProcess(params, 2, 1, 3);
     }
     return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
   }

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, CommonOptimalSwapPath, CommonStepFeeInfo, OptimalSwapPathParams, OptimalSwapPathParamsV2, SwapProviderId, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types';
+import { BaseStepDetail, CommonOptimalSwapPath, CommonStepFeeInfo, 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';
@@ -9,15 +9,13 @@ export declare class SimpleSwapHandler implements SwapBaseInterface {
     private swapBaseHandler;
     providerSlug: SwapProviderId;
     constructor(chainService: ChainService, balanceService: BalanceService, feeService: FeeService);
-    validateSwapProcess(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
     get chainService(): ChainService;
     get balanceService(): BalanceService;
     get providerInfo(): import("@subwallet/extension-base/types").SwapProvider;
     get name(): string;
     get slug(): string;
-    generateOptimalProcess(params: OptimalSwapPathParams): Promise<CommonOptimalSwapPath>;
     generateOptimalProcessV2(params: OptimalSwapPathParamsV2): Promise<CommonOptimalSwapPath>;
-    getSubmitStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
+    getSubmitStep(params: OptimalSwapPathParamsV2, stepIndex: number): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
     handleSwapProcess(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     handleSubmitStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     validateSwapProcessV2(params: ValidateSwapProcessParams): Promise<TransactionError[]>;