@subwallet/extension-base 1.3.31-0 → 1.3.32-0

package/cjs/services/swap-service/handler/base-handler.js

@@ -12,6 +12,7 @@ var _systemPallet = require("@subwallet/extension-base/core/substrate/system-pal
 var _xcmParser = require("@subwallet/extension-base/core/substrate/xcm-parser");
 var _utils = require("@subwallet/extension-base/core/utils");
 var _xcm = require("@subwallet/extension-base/services/balance-service/transfer/xcm");
+var _acrossBridge = require("@subwallet/extension-base/services/balance-service/transfer/xcm/acrossBridge");
 var _utils2 = require("@subwallet/extension-base/services/chain-service/utils");
 var _utils3 = require("@subwallet/extension-base/services/swap-service/utils");
 var _types = require("@subwallet/extension-base/types");
@@ -22,6 +23,7 @@ var _getId = require("@subwallet/extension-base/utils/getId");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 var _i18next = require("i18next");
 var _utilCrypto = require("@polkadot/util-crypto");
+var _xcm2 = require("../../balance-service/transfer/xcm");
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
@@ -59,6 +61,10 @@ class SwapBaseHandler {
       }
       return result;
     } catch (e) {
+      const errorMessage = e.message;
+      if (errorMessage.toLowerCase().startsWith(_acrossBridge.AcrossErrorMsg.AMOUNT_TOO_LOW) || errorMessage.toLowerCase().startsWith(_acrossBridge.AcrossErrorMsg.AMOUNT_TOO_HIGH)) {
+        throw new Error(errorMessage);
+      }
       return result;
     }
   }
@@ -192,7 +198,16 @@ class SwapBaseHandler {
       return undefined;
     }
   }
-  async handleBridgeStep(params) {
+  async handleBridgeStep(params, type) {
+    if (type === 'xcm') {
+      return this.handleBridgeSubstrate(params);
+    }
+    if (type === 'across') {
+      return this.handleBridgeAcross(params);
+    }
+    throw Error('Not support this type');
+  }
+  async handleBridgeSubstrate(params) {
     const briefXcmStep = params.process.steps[params.currentStep].metadata;
     if (!briefXcmStep || !briefXcmStep.originTokenInfo || !briefXcmStep.destinationTokenInfo || !briefXcmStep.sendingValue) {
       throw new Error('XCM metadata error');
@@ -237,6 +252,49 @@ class SwapBaseHandler {
       txData: xcmData
     };
   }
+  async handleBridgeAcross(params) {
+    const bridgeStep = params.process.steps[params.currentStep].metadata;
+    if (!bridgeStep || !bridgeStep.originTokenInfo || !bridgeStep.destinationTokenInfo || !bridgeStep.sendingValue) {
+      throw new Error('Bridge metadata error');
+    }
+    const originTokenInfo = bridgeStep.originTokenInfo;
+    const destinationTokenInfo = bridgeStep.destinationTokenInfo;
+    const originChain = this.chainService.getChainInfoByKey(originTokenInfo.originChain);
+    const destinationChain = this.chainService.getChainInfoByKey(destinationTokenInfo.originChain);
+    const evmApi = await this.chainService.getEvmApi(originTokenInfo.originChain).isReady;
+    const feeInfo = await this.feeService.subscribeChainFee((0, _getId.getId)(), originTokenInfo.originChain, 'evm');
+    const sendingValue = bridgeStep.sendingValue;
+    const sender = bridgeStep.sender;
+    const recipient = bridgeStep.receiver;
+    const tx = await (0, _xcm2.createAcrossBridgeExtrinsic)({
+      originTokenInfo,
+      destinationTokenInfo,
+      originChain,
+      destinationChain,
+      evmApi,
+      feeInfo,
+      sendingValue,
+      sender,
+      recipient
+    });
+    const txData = {
+      originNetworkKey: originTokenInfo.originChain,
+      destinationNetworkKey: destinationTokenInfo.originChain,
+      from: sender,
+      to: recipient,
+      value: sendingValue,
+      tokenSlug: originTokenInfo.slug,
+      showExtraWarning: true
+    };
+    return {
+      txChain: originTokenInfo.originChain,
+      extrinsic: tx,
+      transferNativeAmount: (0, _utils2._isNativeToken)(originTokenInfo) ? bridgeStep.sendingValue : '0',
+      extrinsicType: _KoniTypes.ExtrinsicType.TRANSFER_XCM,
+      chainType: _KoniTypes.ChainType.EVM,
+      txData: txData
+    };
+  }
   async validateSetFeeTokenStep(params, stepIndex) {
     if (!params.selectedQuote) {
       return Promise.resolve([new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)]);
@@ -269,27 +327,29 @@ class SwapBaseHandler {
         }
       }))];
     }
+    const isAcrossBridge = (0, _acrossBridge._isAcrossChainBridge)((0, _utils2._getAssetOriginChain)(fromToken), (0, _utils2._getAssetOriginChain)(toToken));
+    if (!isAcrossBridge) {
+      // By here, we know that the user is receiving a valid amount of toToken
+      const toChainApi = this.chainService.getSubstrateApi(toToken.originChain);
+      const sufficientChain = this.chainService.value.sufficientChains;
+      if (!toChainApi) {
+        return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+      }
 
-    // By here, we know that the user is receiving a valid amount of toToken
-    const toChainApi = this.chainService.getSubstrateApi(toToken.originChain);
-    const sufficientChain = this.chainService.value.sufficientChains;
-    if (!toChainApi) {
-      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
-    }
-
-    // Only need to check if account is alive with the receiving toToken
-    const isToTokenSufficient = await (0, _utils._isSufficientToken)(toToken, toChainApi, sufficientChain);
-    if (!isToTokenSufficient && !(0, _utils2._isNativeToken)(toToken)) {
-      // sending token cannot keep account alive, must check with native token
-      const toChainNativeTokenBalance = await this.balanceService.getTotalBalance(receiver, toToken.originChain, toChainNativeToken.slug, _KoniTypes.ExtrinsicType.TRANSFER_BALANCE);
-      if (!(0, _systemPallet._isAccountActive)(toChainNativeTokenBalance.metadata)) {
-        return [new _TransactionError.TransactionError(_types.TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, (0, _i18next.t)('The recipient account has less than {{amount}} {{nativeSymbol}}, which can lead to your {{localSymbol}} being lost. Change recipient account and try again', {
-          replace: {
-            amount: toChainNativeTokenBalance.value,
-            nativeSymbol: toChainNativeToken.symbol,
-            localSymbol: toToken.symbol
-          }
-        }))];
+      // Only need to check if account is alive with the receiving toToken
+      const isToTokenSufficient = await (0, _utils._isSufficientToken)(toToken, toChainApi, sufficientChain);
+      if (!isToTokenSufficient && !(0, _utils2._isNativeToken)(toToken)) {
+        // sending token cannot keep account alive, must check with native token
+        const toChainNativeTokenBalance = await this.balanceService.getTotalBalance(receiver, toToken.originChain, toChainNativeToken.slug, _KoniTypes.ExtrinsicType.TRANSFER_BALANCE);
+        if (!(0, _systemPallet._isAccountActive)(toChainNativeTokenBalance.metadata)) {
+          return [new _TransactionError.TransactionError(_types.TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, (0, _i18next.t)('The recipient account has less than {{amount}} {{nativeSymbol}}, which can lead to your {{localSymbol}} being lost. Change recipient account and try again', {
+            replace: {
+              amount: toChainNativeTokenBalance.value,
+              nativeSymbol: toChainNativeToken.symbol,
+              localSymbol: toToken.symbol
+            }
+          }))];
+        }
       }
     }
     return [];

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

@@ -286,7 +286,7 @@ class HydradxHandler {
       case _serviceBase.CommonStepType.DEFAULT:
         return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
       case _serviceBase.CommonStepType.XCM:
-        return this.swapBaseHandler.handleBridgeStep(params);
+        return this.swapBaseHandler.handleBridgeStep(params, 'xcm');
       case _serviceBase.CommonStepType.SET_FEE_TOKEN:
         return this.handleSetFeeStep(params);
       case _swap.SwapStepType.SWAP:

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

@@ -8,8 +8,12 @@ exports.UniswapHandler = void 0;
 var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
 var _logicValidation = require("@subwallet/extension-base/core/logic-validation");
+var _web = require("@subwallet/extension-base/koni/api/contract-handler/evm/web3");
+var _xcm = require("@subwallet/extension-base/services/balance-service/transfer/xcm");
+var _acrossBridge = require("@subwallet/extension-base/services/balance-service/transfer/xcm/acrossBridge");
 var _types = require("@subwallet/extension-base/types");
 var _utils = require("@subwallet/extension-base/utils");
+var _getId = require("@subwallet/extension-base/utils/getId");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 var _utils2 = require("../../chain-service/utils");
 var _utils3 = require("../../fee-service/utils");
@@ -66,41 +70,121 @@ class UniswapHandler {
     return this.swapBaseHandler.providerInfo;
   }
   generateOptimalProcessV2(params) {
-    return this.swapBaseHandler.generateOptimalProcessV2(params, [this.getApprovalStep.bind(this), this.getPermitStep.bind(this), this.getSubmitStep.bind(this)]);
+    const stepFuncList = [];
+    /**
+     * approve - permit - swap or
+     * approve - permit - swap - approve - bridge
+     */
+
+    params.path.forEach(step => {
+      if (step.action === _types.DynamicSwapType.SWAP) {
+        stepFuncList.push(...[this.getApprovalStep.bind(this), this.getPermitStep.bind(this), this.getSubmitStep.bind(this)]);
+        return;
+      }
+      if (step.action === _types.DynamicSwapType.BRIDGE) {
+        stepFuncList.push(...[this.getApprovalStep.bind(this), this.getBridgeStep.bind(this)]);
+        return;
+      }
+      throw new Error(`Error generating optimal process: Action ${step.action} is not supported`);
+    });
+    return this.swapBaseHandler.generateOptimalProcessV2(params, stepFuncList);
   }
   async getApprovalStep(params, stepIndex) {
-    if (params.selectedQuote) {
-      const walletAddress = params.request.address;
-      const fromAmount = params.selectedQuote.fromAmount;
-      const inputTokenInfo = this.chainService.getAssetBySlug(params.selectedQuote.pair.from);
-      const {
-        quote
-      } = params.selectedQuote.metadata;
-      const checkApprovalResponse = await fetchCheckApproval(walletAddress, fromAmount, quote);
-      const approval = checkApprovalResponse.approval;
-      if (approval) {
-        let spender = '';
-        try {
-          const valueLength = 40;
-          spender = approval.data.slice(-(valueLength * 2), -valueLength);
-        } catch (e) {
-          // Empty
-        }
-        const metadata = {
-          tokenApprove: inputTokenInfo.slug,
-          contractAddress: (0, _utils2._getContractAddressOfToken)(inputTokenInfo),
-          spenderAddress: spender
-        };
-        const submitStep = {
-          name: 'Approve token',
-          type: _types.CommonStepType.TOKEN_APPROVAL,
-          metadata: metadata
-        };
-        return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
-      }
+    if (stepIndex === 0) {
+      return this.getApproveSwap(params);
+    }
+    if (stepIndex === 3) {
+      return this.getApproveBridge(params);
     }
     return Promise.resolve(undefined);
   }
+  async getApproveSwap(params) {
+    const selectedQuote = params.selectedQuote;
+    if (!selectedQuote) {
+      return Promise.resolve(undefined);
+    }
+    const quoteMetadata = selectedQuote.metadata.quote;
+    const sender = quoteMetadata.swapper;
+    const sendingValue = quoteMetadata.input.amount;
+    const fromTokenInfo = this.chainService.getAssetBySlug(selectedQuote.pair.from);
+    const checkApprovalResponse = await fetchCheckApproval(sender, sendingValue, quoteMetadata);
+    const approval = checkApprovalResponse.approval;
+    if (!approval) {
+      return Promise.resolve(undefined);
+    }
+    let spender = '';
+    try {
+      const valueLength = 40;
+      spender = approval.data.slice(-(valueLength * 2), -valueLength);
+    } catch (e) {
+      // Empty
+    }
+    const submitStep = {
+      name: 'Approve token for swap',
+      type: _types.CommonStepType.TOKEN_APPROVAL,
+      // @ts-ignore
+      metadata: {
+        tokenApprove: fromTokenInfo.slug,
+        contractAddress: (0, _utils2._getContractAddressOfToken)(fromTokenInfo),
+        spenderAddress: spender,
+        owner: sender,
+        amount: sendingValue,
+        isUniswapApprove: true
+      }
+    };
+    return Promise.resolve([submitStep, selectedQuote.feeInfo]); // todo: wrong feeInfo, please check
+  }
+
+  async getApproveBridge(params) {
+    const quote = params.selectedQuote;
+    if (!quote) {
+      return Promise.resolve(undefined);
+    }
+    const sendingAmount = quote.toAmount;
+    const senderAddress = params.request.address;
+    const fromTokenInfo = this.chainService.getAssetBySlug(quote.pair.to);
+    const fromChainInfo = this.chainService.getChainInfoByKey((0, _utils2._getAssetOriginChain)(fromTokenInfo));
+    const fromChainId = (0, _utils2._getEvmChainId)(fromChainInfo);
+    const evmApi = this.chainService.getEvmApi(fromChainInfo.slug);
+    const tokenContract = (0, _utils2._getContractAddressOfToken)(fromTokenInfo);
+    if ((0, _utils2._isNativeToken)(fromTokenInfo)) {
+      return Promise.resolve(undefined);
+    }
+    if (!fromChainId) {
+      throw Error('Error getting Evm chain Id');
+    }
+    const spokePoolAddress = _acrossBridge.SpokePoolMapping[fromChainId].SpokePool.address;
+    const allowance = await (0, _web.getERC20Allowance)(spokePoolAddress, senderAddress, tokenContract, evmApi);
+    if (allowance && (0, _bignumber.default)(allowance).gt(sendingAmount)) {
+      return Promise.resolve(undefined);
+    }
+    const tx = await (0, _web.getERC20SpendingApprovalTx)(spokePoolAddress, senderAddress, tokenContract, evmApi);
+    const evmFeeInfo = await this.feeService.subscribeChainFee((0, _getId.getId)(), fromTokenInfo.originChain, 'evm');
+    const estimatedFee = await (0, _web.estimateTxFee)(tx, evmApi, evmFeeInfo);
+    const nativeTokenSlug = (0, _utils2._getChainNativeTokenSlug)(fromChainInfo);
+    const feeInfo = {
+      feeComponent: [{
+        feeType: _types.SwapFeeType.NETWORK_FEE,
+        amount: estimatedFee,
+        tokenSlug: nativeTokenSlug
+      }],
+      defaultFeeToken: nativeTokenSlug,
+      feeOptions: [nativeTokenSlug]
+    };
+    const submitStep = {
+      name: 'Approve token for bridge',
+      type: _types.CommonStepType.TOKEN_APPROVAL,
+      // @ts-ignore
+      metadata: {
+        tokenApprove: fromTokenInfo.slug,
+        contractAddress: tokenContract,
+        spenderAddress: spokePoolAddress,
+        amount: sendingAmount,
+        owner: senderAddress
+      }
+    };
+    return Promise.resolve([submitStep, feeInfo]);
+  }
   async getPermitStep(params, stepIndex) {
     if (params.selectedQuote && params.selectedQuote.metadata.permitData) {
       const submitStep = {
@@ -123,11 +207,22 @@ class UniswapHandler {
     return Promise.resolve(undefined);
   }
   async getSubmitStep(params, stepIndex) {
-    if (!params.selectedQuote) {
+    const {
+      path,
+      request,
+      selectedQuote
+    } = params;
+
+    // stepIndex is not corresponding index in path, because uniswap include approval and permit step
+    const stepData = path.find(action => action.action === _types.DynamicSwapType.SWAP);
+    if (!stepData || !stepData.pair) {
+      return Promise.resolve(undefined);
+    }
+    if (!selectedQuote) {
       return Promise.resolve(undefined);
     }
-    const originTokenInfo = this.chainService.getAssetBySlug(params.selectedQuote.pair.from);
-    const destinationTokenInfo = this.chainService.getAssetBySlug(params.selectedQuote.pair.to);
+    const originTokenInfo = this.chainService.getAssetBySlug(selectedQuote.pair.from);
+    const destinationTokenInfo = this.chainService.getAssetBySlug(selectedQuote.pair.to);
     const originChain = this.chainService.getChainInfoByKey(originTokenInfo.originChain);
     const destinationChain = this.chainService.getChainInfoByKey(destinationTokenInfo.originChain);
     const submitStep = {
@@ -135,16 +230,99 @@ class UniswapHandler {
       type: _types.SwapStepType.SWAP,
       // @ts-ignore
       metadata: {
-        sendingValue: params.request.fromAmount.toString(),
-        expectedReceive: params.selectedQuote.toAmount,
+        sendingValue: request.fromAmount.toString(),
+        expectedReceive: selectedQuote.toAmount,
         originTokenInfo,
         destinationTokenInfo,
-        sender: (0, _utils._reformatAddressWithChain)(params.request.address, originChain),
-        receiver: (0, _utils._reformatAddressWithChain)(params.request.recipient || params.request.address, destinationChain),
+        sender: (0, _utils._reformatAddressWithChain)(request.address, originChain),
+        receiver: (0, _utils._reformatAddressWithChain)(request.recipient || request.address, destinationChain),
         version: 2
       }
     };
-    return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
+    return Promise.resolve([submitStep, selectedQuote.feeInfo]);
+  }
+  async getBridgeStep(params, stepIndex) {
+    const {
+      path,
+      request,
+      selectedQuote
+    } = params;
+
+    // stepIndex is not corresponding index in path, because uniswap include approval and permit step
+    const bridgePairInfo = path.find(action => action.action === _types.DynamicSwapType.BRIDGE);
+    if (!bridgePairInfo || !bridgePairInfo.pair) {
+      return Promise.resolve(undefined);
+    }
+    if (!selectedQuote) {
+      return Promise.resolve(undefined);
+    }
+    const fromTokenInfo = this.chainService.getAssetBySlug(bridgePairInfo.pair.from);
+    const toTokenInfo = this.chainService.getAssetBySlug(bridgePairInfo.pair.to);
+    const fromChainInfo = this.chainService.getChainInfoByKey(fromTokenInfo.originChain);
+    const toChainInfo = this.chainService.getChainInfoByKey(toTokenInfo.originChain);
+    if (!fromChainInfo || !toChainInfo || !fromChainInfo || !toChainInfo) {
+      throw Error('Token or chain not found');
+    }
+    const senderAddress = (0, _utils._reformatAddressWithChain)(request.address, fromChainInfo);
+    const receiverAddress = (0, _utils._reformatAddressWithChain)(request.recipient || request.address, toChainInfo);
+    const sendingValue = (0, _bignumber.default)(selectedQuote.toAmount).div(1.02).toFixed(0, 1);
+    try {
+      const evmApi = await this.chainService.getEvmApi(fromChainInfo.slug).isReady;
+      const feeInfo = await this.feeService.subscribeChainFee((0, _getId.getId)(), fromTokenInfo.originChain, 'evm');
+      const tx = await (0, _xcm.createAcrossBridgeExtrinsic)({
+        originTokenInfo: fromTokenInfo,
+        destinationTokenInfo: toTokenInfo,
+        originChain: fromChainInfo,
+        destinationChain: toChainInfo,
+        evmApi,
+        feeInfo,
+        // Mock sending value to get payment info
+        sendingValue,
+        sender: senderAddress,
+        recipient: receiverAddress
+      });
+
+      // // todo: wait until this ready to get destination fee. the real receiveAmount is deduce by this fee
+      // const acrossQuote = await getAcrossQuote({
+      //   destinationChain: toChainInfo,
+      //   destinationTokenInfo: toTokenInfo,
+      //   originChain: fromChainInfo,
+      //   originTokenInfo: fromTokenInfo,
+      //   recipient: receiverAddress,
+      //   sender: senderAddress,
+      //   sendingValue,
+      //   feeInfo
+      // });
+
+      const estimatedBridgeFee = await (0, _web.estimateTxFee)(tx, evmApi, feeInfo);
+      const expectedReceive = (0, _bignumber.default)(sendingValue).minus(estimatedBridgeFee).toFixed(0, 1);
+      const fee = {
+        feeComponent: [{
+          feeType: _types.SwapFeeType.NETWORK_FEE,
+          amount: estimatedBridgeFee,
+          tokenSlug: (0, _utils2._getChainNativeTokenSlug)(fromChainInfo)
+        }],
+        defaultFeeToken: (0, _utils2._getChainNativeTokenSlug)(fromChainInfo),
+        feeOptions: [(0, _utils2._getChainNativeTokenSlug)(fromChainInfo)]
+      };
+      const step = {
+        // @ts-ignore
+        metadata: {
+          sendingValue: sendingValue,
+          expectedReceive,
+          originTokenInfo: fromTokenInfo,
+          destinationTokenInfo: toTokenInfo,
+          receiver: receiverAddress,
+          sender: senderAddress
+        },
+        name: `Transfer ${fromTokenInfo.symbol} from ${fromChainInfo.name}`,
+        type: _types.CommonStepType.XCM
+      };
+      return [step, fee];
+    } catch (e) {
+      console.error('Error creating bridge step', e);
+      throw new Error(e.message);
+    }
   }
   async handleSwapProcess(params) {
     const {
@@ -157,6 +335,8 @@ class UniswapHandler {
         return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
       case _types.CommonStepType.TOKEN_APPROVAL:
         return this.tokenApproveSpending(params);
+      case _types.CommonStepType.XCM:
+        return this.swapBaseHandler.handleBridgeStep(params, 'across');
       case _types.SwapStepType.SWAP:
         return this.handleSubmitStep(params);
       case _types.SwapStepType.PERMIT:
@@ -166,13 +346,29 @@ class UniswapHandler {
     }
   }
   async tokenApproveSpending(params) {
-    const fromAsset = this.chainService.getAssetBySlug(params.quote.pair.from);
-    const walletAddress = params.address;
-    const fromAmount = params.quote.fromAmount;
+    const approveStep = params.process.steps[params.currentStep].metadata;
+    if (!approveStep || !approveStep.tokenApprove || !approveStep.contractAddress || !approveStep.spenderAddress) {
+      throw new Error('Approval spending metadata error');
+    }
+    if (approveStep.isUniswapApprove) {
+      return this.approveSpendingSwap(params, approveStep);
+    }
+    return this.approveSpendingBridge(approveStep);
+  }
+  async approveSpendingSwap(params, approveStep) {
+    const fromAsset = this.chainService.getAssetBySlug(approveStep.tokenApprove);
+    const sender = approveStep.owner;
+    const sendingValue = approveStep.amount;
+    if (!sender || !sendingValue) {
+      throw new Error('Sender or value is not found');
+    }
+
+    // todo: move quote param to metadata;
+
     const {
       quote
     } = params.quote.metadata;
-    const checkApprovalResponse = await fetchCheckApproval(walletAddress, fromAmount, quote);
+    const checkApprovalResponse = await fetchCheckApproval(sender, sendingValue, quote);
     let transactionConfig = {};
     const approval = checkApprovalResponse.approval;
     if (approval) {
@@ -208,6 +404,34 @@ class UniswapHandler {
       chainType: _KoniTypes.ChainType.EVM
     });
   }
+  async approveSpendingBridge(approveStep) {
+    const fromAsset = this.chainService.getAssetBySlug(approveStep.tokenApprove);
+    const fromChain = (0, _utils2._getAssetOriginChain)(fromAsset);
+    const evmApi = this.chainService.getEvmApi(fromAsset.originChain);
+    const sender = approveStep.owner;
+    const sendingValue = approveStep.amount;
+    if (!sender) {
+      throw new Error('Sender or value is not found');
+    }
+    const spenderAddress = approveStep.spenderAddress;
+    const contractAddress = approveStep.contractAddress;
+    const transactionConfig = await (0, _web.getERC20SpendingApprovalTx)(spenderAddress, sender, contractAddress, evmApi);
+    const _data = {
+      spenderAddress: approveStep.spenderAddress,
+      contractAddress: approveStep.contractAddress,
+      amount: sendingValue,
+      owner: sender,
+      chain: fromChain
+    };
+    return Promise.resolve({
+      txChain: fromChain,
+      extrinsicType: _KoniTypes.ExtrinsicType.TOKEN_SPENDING_APPROVAL,
+      extrinsic: transactionConfig,
+      txData: _data,
+      transferNativeAmount: '0',
+      chainType: _KoniTypes.ChainType.EVM
+    });
+  }
   async handleSubmitStep(params) {
     const fromAsset = this.chainService.getAssetBySlug(params.quote.pair.from);
     const {
@@ -241,6 +465,8 @@ class UniswapHandler {
       const transactionResponse = await postTransactionResponse.json();
       extrinsic = transactionResponse.swap;
     } else if (routing === 'DUTCH_LIMIT' || routing === 'DUTCH_V2') {
+      // todo: update condition and add handle exception
+      // UniswapX, UniswapX_V2, and UniswapX_V3 are alternately referred to as DutchQuote, DutchQuoteV2, and DutchQuoteV3
       postTransactionResponse = await fetch(`${API_URL}/order`, {
         method: 'POST',
         headers: {
@@ -332,17 +558,20 @@ class UniswapHandler {
     const swapXcm = actionList === JSON.stringify([_types.DynamicSwapType.SWAP, _types.DynamicSwapType.BRIDGE]);
     const xcmSwap = actionList === JSON.stringify([_types.DynamicSwapType.BRIDGE, _types.DynamicSwapType.SWAP]);
     const xcmSwapXcm = actionList === JSON.stringify([_types.DynamicSwapType.BRIDGE, _types.DynamicSwapType.SWAP, _types.DynamicSwapType.BRIDGE]);
-    const swapIndex = params.process.steps.findIndex(step => step.type === _types.SwapStepType.SWAP); // todo
-
+    const swapIndex = params.process.steps.findIndex(step => step.type === _types.SwapStepType.SWAP);
+    const bridgeIndex = params.process.steps.findIndex(step => step.type === _types.CommonStepType.XCM);
     if (swapIndex <= -1) {
       return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
     }
+    if (swapXcm && bridgeIndex <= -1) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
     if (swap) {
       return this.swapBaseHandler.validateSwapOnlyProcess(params, swapIndex); // todo: create interface for input request
     }
 
     if (swapXcm) {
-      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+      return this.swapBaseHandler.validateSwapXcmProcess(params, swapIndex, bridgeIndex);
     }
     if (xcmSwap) {
       return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];

package/cjs/services/swap-service/index.js

@@ -117,16 +117,22 @@ class SwapService {
       path,
       swapQuoteResponse
     } = await this.getLatestQuoteFromSwapRequest(request);
-    const optimalProcess = await this.generateOptimalProcessV2({
-      request,
-      selectedQuote: swapQuoteResponse.optimalQuote,
-      path
-    });
-    console.log('-------');
+    console.group('Swap Logger');
+    console.log('path', path);
+    console.log('swapQuoteResponse', swapQuoteResponse);
+    let optimalProcess;
+    try {
+      optimalProcess = await this.generateOptimalProcessV2({
+        request,
+        selectedQuote: swapQuoteResponse.optimalQuote,
+        path
+      });
+    } catch (e) {
+      throw new Error(e.message);
+    }
     console.log('optimalProcess', optimalProcess);
-    console.log('-------');
-    if (optimalProcess.steps.length - 1 < optimalProcess.path.length) {
-      // minus the fill info step
+    console.groupEnd();
+    if (JSON.stringify((0, _utils2.processStepsToPathActions)(optimalProcess.steps)) !== JSON.stringify(optimalProcess.path.map(e => e.action))) {
       throw new Error('Swap pair is not found');
     }
     return {
@@ -142,7 +148,7 @@ class SwapService {
       pair
     } = request;
     // todo: control provider tighter
-    const supportSwapChains = (0, _utils2.getSupportSwapChain)();
+    const supportSwapChains = (0, _utils2.getSupportedSwapChains)();
     const fromToken = this.chainService.getAssetBySlug(pair.from);
     const toToken = this.chainService.getAssetBySlug(pair.to);
     const fromChain = (0, _utils._getAssetOriginChain)(fromToken);
@@ -244,10 +250,26 @@ class SwapService {
     return [[], undefined];
   }
   async getLatestQuoteFromSwapRequest(request) {
-    const [path, directSwapRequest] = this.getAvailablePath(request);
+    var _subwalletApiSdk$swap2;
+    const availablePath = await ((_subwalletApiSdk$swap2 = _subwalletApiSdk.default.swapApi) === null || _subwalletApiSdk$swap2 === void 0 ? void 0 : _subwalletApiSdk$swap2.findAvailablePath(request));
+    if (!availablePath) {
+      throw Error('No available path');
+    }
+    const {
+      path
+    } = availablePath;
+    const swapAction = path.find(step => step.action === _types3.DynamicSwapType.SWAP);
+    const directSwapRequest = swapAction ? {
+      ...request,
+      address: (0, _utils3._reformatAddressWithChain)(request.address, this.chainService.getChainInfoByKey((0, _utils._getAssetOriginChain)(this.chainService.getAssetBySlug(swapAction.pair.from)))),
+      pair: swapAction.pair
+    } : undefined;
     if (!directSwapRequest) {
       throw Error('Swap pair is not found');
     }
+    if (path.length > 1 && path.map(action => action.action).includes(_types3.DynamicSwapType.BRIDGE)) {
+      directSwapRequest.isCrossChain = true;
+    }
     const swapQuoteResponse = await this.getLatestDirectQuotes(directSwapRequest);
     return {
       path,

package/cjs/services/swap-service/utils.js

@@ -18,13 +18,14 @@ exports.getChainflipOptions = getChainflipOptions;
 exports.getChainflipSwap = getChainflipSwap;
 exports.getFirstAmountFromSteps = getFirstAmountFromSteps;
 exports.getLastAmountFromSteps = getLastAmountFromSteps;
-exports.getSupportSwapChain = getSupportSwapChain;
+exports.getSupportedSwapChains = getSupportedSwapChains;
 exports.getSwapAltToken = getSwapAltToken;
 exports.getSwapAlternativeAsset = getSwapAlternativeAsset;
 exports.getSwapChainsFromPath = getSwapChainsFromPath;
 exports.getSwapStep = getSwapStep;
 exports.getTokenPairFromStep = getTokenPairFromStep;
 exports.isChainsHasSameProvider = isChainsHasSameProvider;
+exports.processStepsToPathActions = processStepsToPathActions;
 var _chainList = require("@subwallet/chain-list");
 var _types = require("@subwallet/chain-list/types");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
@@ -76,7 +77,7 @@ const FEE_RATE_MULTIPLIER = {
   high: 2
 };
 exports.FEE_RATE_MULTIPLIER = FEE_RATE_MULTIPLIER;
-function getSupportSwapChain() {
+function getSupportedSwapChains() {
   return [...new Set(Object.values(_PROVIDER_TO_SUPPORTED_PAIR_MAP).flat())];
 }
 function getSwapAlternativeAsset(swapPair) {
@@ -270,5 +271,17 @@ function getSwapChainsFromPath(path) {
   });
   return swapChains;
 }
+function processStepsToPathActions(steps) {
+  const path = [];
+  for (const step of steps) {
+    if (step.type === _types2.CommonStepType.XCM) {
+      path.push(_types2.DynamicSwapType.BRIDGE);
+    }
+    if (step.type === _types2.SwapStepType.SWAP) {
+      path.push(_types2.DynamicSwapType.SWAP);
+    }
+  }
+  return path;
+}
 const DEFAULT_EXCESS_AMOUNT_WEIGHT = 1.04; // add 2%
 exports.DEFAULT_EXCESS_AMOUNT_WEIGHT = DEFAULT_EXCESS_AMOUNT_WEIGHT;