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

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

@@ -2,18 +2,19 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
-import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { validateSpendingAndFeePayment } from '@subwallet/extension-base/core/logic-validation';
-import { _validateBalanceToSwap, _validateSwapRecipient } from '@subwallet/extension-base/core/logic-validation/swap';
 import { _isAccountActive } from '@subwallet/extension-base/core/substrate/system-pallet';
-import { _isSnowBridgeXcm } from '@subwallet/extension-base/core/substrate/xcm-parser';
+import { _isAcrossBridgeXcm, _isSnowBridgeXcm, _isXcmWithinSameConsensus } from '@subwallet/extension-base/core/substrate/xcm-parser';
 import { _isSufficientToken } from '@subwallet/extension-base/core/utils';
-import { _getAssetDecimals, _getAssetSymbol, _getTokenMinAmount, _isChainEvmCompatible, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
-import { FEE_RATE_MULTIPLIER, getSwapAlternativeAsset } from '@subwallet/extension-base/services/swap-service/utils';
-import { BasicTxErrorType, TransferTxErrorType } from '@subwallet/extension-base/types';
-import { DEFAULT_FIRST_STEP, MOCK_STEP_FEE } from '@subwallet/extension-base/types/service-base';
-import { SwapErrorType, SwapFeeType } from '@subwallet/extension-base/types/swap';
+import { createXcmExtrinsicV2, dryRunXcmExtrinsicV2 } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
+import { _getAssetDecimals, _getAssetSymbol, _getChainNativeTokenSlug, _getTokenMinAmount, _isChainEvmCompatible, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { DEFAULT_EXCESS_AMOUNT_WEIGHT, FEE_RATE_MULTIPLIER } from '@subwallet/extension-base/services/swap-service/utils';
+import { BasicTxErrorType, SwapStepType, TransferTxErrorType } from '@subwallet/extension-base/types';
+import { CommonStepType, DEFAULT_FIRST_STEP, MOCK_STEP_FEE } from '@subwallet/extension-base/types/service-base';
+import { DynamicSwapType, SwapErrorType, SwapFeeType } from '@subwallet/extension-base/types/swap';
 import { _reformatAddressWithChain, balanceFormatter, formatNumber } from '@subwallet/extension-base/utils';
+import { getId } from '@subwallet/extension-base/utils/getId';
 import BigN from 'bignumber.js';
 import { t } from 'i18next';
 import { isEthereumAddress } from '@polkadot/util-crypto';
@@ -31,30 +32,6 @@ export class SwapBaseHandler {
     this.balanceService = balanceService;
     this.feeService = feeService;
   }
-
-  // public abstract getSwapQuote(request: SwapRequest): Promise<SwapQuote | SwapError>;
-  async generateOptimalProcess(params, genStepFuncList) {
-    const result = {
-      totalFee: [MOCK_STEP_FEE],
-      steps: [DEFAULT_FIRST_STEP],
-      path: []
-    };
-    try {
-      for (const genStepFunc of genStepFuncList) {
-        const step = await genStepFunc(params);
-        if (step) {
-          result.steps.push({
-            id: result.steps.length,
-            ...step[0]
-          });
-          result.totalFee.push(step[1]);
-        }
-      }
-      return result;
-    } catch (e) {
-      return result;
-    }
-  }
   async generateOptimalProcessV2(params, genStepFuncList) {
     const result = {
       totalFee: [MOCK_STEP_FEE],
@@ -62,8 +39,8 @@ export class SwapBaseHandler {
       path: params.path
     };
     try {
-      for (const genStepFunc of genStepFuncList) {
-        const step = await genStepFunc(params);
+      for (const [i, genStepFunc] of genStepFuncList.entries()) {
+        const step = await genStepFunc(params, i);
         if (step) {
           result.steps.push({
             id: result.steps.length,
@@ -77,158 +54,180 @@ export class SwapBaseHandler {
       return result;
     }
   }
-  async validateXcmStep(params, stepIndex) {
-    const bnAmount = new BigN(params.selectedQuote.fromAmount);
-    const swapPair = params.selectedQuote.pair;
-    const alternativeAssetSlug = getSwapAlternativeAsset(swapPair);
-    if (!alternativeAssetSlug) {
-      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+  async getBridgeStep(params, stepIndex) {
+    // only xcm on substrate for now
+    const {
+      path,
+      request: {
+        address,
+        fromAmount,
+        recipient
+      },
+      selectedQuote
+    } = params;
+    if (stepIndex < 0 || stepIndex > params.path.length - 1) {
+      return undefined;
+    }
+    const bridgePairInfo = path[stepIndex];
+    if (bridgePairInfo.action !== DynamicSwapType.BRIDGE) {
+      return undefined;
+    }
+    if (!bridgePairInfo || !selectedQuote) {
+      return 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');
+    }
+    let recipientAddress;
+    const senderAddress = _reformatAddressWithChain(address, fromChainInfo);
+    if (stepIndex === 0) {
+      recipientAddress = _reformatAddressWithChain(address, toChainInfo);
+    } else {
+      // bridge after swap
+      recipientAddress = _reformatAddressWithChain(recipient || address, toChainInfo);
+    }
+    if (!_isXcmWithinSameConsensus(fromChainInfo, toChainInfo) || _isSnowBridgeXcm(fromChainInfo, toChainInfo) || _isAcrossBridgeXcm(fromChainInfo, toChainInfo)) {
+      return undefined;
     }
-    const alternativeAsset = this.chainService.getAssetBySlug(alternativeAssetSlug);
-    const fromAsset = this.chainService.getAssetBySlug(swapPair.from);
-    const [alternativeAssetBalance, fromAssetBalance] = await Promise.all([this.balanceService.getTransferableBalance(params.address, alternativeAsset.originChain, alternativeAssetSlug), this.balanceService.getTransferableBalance(params.address, fromAsset.originChain, fromAsset.slug)]);
-    const bnAlternativeAssetBalance = new BigN(alternativeAssetBalance.value);
-    const bnFromAssetBalance = new BigN(fromAssetBalance.value);
-    const xcmFeeComponent = params.process.totalFee[stepIndex].feeComponent[0]; // todo: can do better than indexing
-    const xcmFee = new BigN(xcmFeeComponent.amount || '0');
-    let xcmAmount = bnAmount.minus(bnFromAssetBalance);
-    let editedXcmFee = new BigN(0);
-    if (_isNativeToken(alternativeAsset)) {
-      xcmAmount = xcmAmount.plus(xcmFee);
-      editedXcmFee = xcmFee.times(2);
-    }
-    if (!bnAlternativeAssetBalance.minus(_isNativeToken(alternativeAsset) ? xcmAmount.plus(xcmFee) : xcmFee).gt(0)) {
-      const maxBn = bnFromAssetBalance.plus(new BigN(alternativeAssetBalance.value)).minus(_isNativeToken(alternativeAsset) ? editedXcmFee : xcmFee);
-      const maxValue = formatNumber(maxBn.toString(), fromAsset.decimals || 0);
-      const altInputTokenInfo = this.chainService.getAssetBySlug(alternativeAssetSlug);
-      const symbol = altInputTokenInfo.symbol;
-      const alternativeChain = this.chainService.getChainInfoByKey(altInputTokenInfo.originChain);
-      const chain = this.chainService.getChainInfoByKey(fromAsset.originChain);
-      const inputNetworkName = chain.name;
-      const altNetworkName = alternativeChain.name;
-      const currentValue = formatNumber(bnFromAssetBalance.toString(), fromAsset.decimals || 0);
-      const bnMaxXCM = new BigN(alternativeAssetBalance.value).minus(_isNativeToken(alternativeAsset) ? editedXcmFee : xcmFee);
-      const maxXCMValue = formatNumber(bnMaxXCM.toString(), fromAsset.decimals || 0);
-      if (maxBn.lte(0) || bnFromAssetBalance.lte(0) || bnMaxXCM.lte(0)) {
-        return [new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE, t(`Insufficient balance. Deposit ${fromAsset.symbol} and try again.`))];
+    try {
+      if (!this.chainService.getChainStateByKey(toTokenInfo.originChain).active) {
+        await this.chainService.enableChain(toTokenInfo.originChain);
       }
-      return [new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE, t('You can only enter a maximum of {{maxValue}} {{symbol}}, which is {{currentValue}} {{symbol}} ({{inputNetworkName}}) and {{maxXCMValue}} {{symbol}} ({{altNetworkName}}). Lower your amount and try again.', {
-        replace: {
-          symbol,
-          maxValue,
-          inputNetworkName,
-          altNetworkName,
-          currentValue,
-          maxXCMValue
-        }
-      }))];
-    }
-    return [];
-  }
-  async validateXcmStepV2(params, stepIndex) {
-    var _currentFee$feeCompon, _params$recipient;
-    const currentStep = params.process.steps[stepIndex];
-    const currentFee = params.process.totalFee[stepIndex];
-    const feeToken = currentFee.selectedFeeToken || currentFee.defaultFeeToken;
-    const feeAmount = (_currentFee$feeCompon = currentFee.feeComponent.find(fee => fee.feeType === SwapFeeType.NETWORK_FEE)) === null || _currentFee$feeCompon === void 0 ? void 0 : _currentFee$feeCompon.amount;
-    if (!feeAmount) {
-      throw new Error('Fee not found for XCM step');
-    }
-    const metadata = currentStep.metadata;
-    const sendingAmount = metadata.sendingValue;
-    const bnAmount = new BigN(sendingAmount);
-    const fromAsset = metadata === null || metadata === void 0 ? void 0 : metadata.originTokenInfo;
-    const toAsset = metadata === null || metadata === void 0 ? void 0 : metadata.destinationTokenInfo;
-    if (!fromAsset || !toAsset) {
-      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
-    }
-    const fromChain = this.chainService.getChainInfoByKey(fromAsset.originChain);
-    const toChain = this.chainService.getChainInfoByKey(toAsset.originChain);
-    const toChainNativeAsset = this.chainService.getNativeTokenInfo(toAsset.originChain);
-    const sender = _reformatAddressWithChain(params.address, fromChain);
-    const receiver = _reformatAddressWithChain((_params$recipient = params.recipient) !== null && _params$recipient !== void 0 ? _params$recipient : sender, toChain);
-
-    /* Get transferable balance */
-    const [fromAssetBalance, feeTokenBalance] = await Promise.all([this.balanceService.getTransferableBalance(sender, fromAsset.originChain, fromAsset.slug, ExtrinsicType.TRANSFER_XCM), this.balanceService.getTransferableBalance(sender, fromAsset.originChain, feeToken, ExtrinsicType.TRANSFER_XCM)]);
-    const bnFromAssetBalance = new BigN(fromAssetBalance.value);
-    const bnFeeTokenBalance = new BigN(feeTokenBalance.value);
-
-    /* Compare transferable balance with amount xcm */
-    if (bnFromAssetBalance.lt(bnAmount)) {
-      return [new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE, t(`Insufficient balance. Deposit ${fromAsset.symbol} and try again.`))];
-    }
-
-    /**
-     * Calculate fee token keep alive after xcm
-     * If fee token is the same as from token, need to subtract sending amount
-     * @TODO: Need to update logic if change fee token (multi with rate)
-     * */
-    const feeBalanceAfterTransfer = bnFeeTokenBalance.minus(feeAmount).minus(fromAsset.slug === feeToken ? bnAmount : 0);
+      const substrateApi = await this.chainService.getSubstrateApi(fromTokenInfo.originChain).isReady;
+      const id = getId();
+      const [feeInfo, toTokenBalance] = await Promise.all([this.feeService.subscribeChainFee(id, fromTokenInfo.originChain, 'substrate'), this.balanceService.getTotalBalance(senderAddress, toTokenInfo.originChain, toTokenInfo.slug, ExtrinsicType.TRANSFER_BALANCE)]);
+      const mockSendingValue = stepIndex === 0 ? fromAmount : (selectedQuote === null || selectedQuote === void 0 ? void 0 : selectedQuote.toAmount) || '0';
+      const xcmRequest = {
+        originTokenInfo: fromTokenInfo,
+        destinationTokenInfo: toTokenInfo,
+        originChain: fromChainInfo,
+        destinationChain: toChainInfo,
+        substrateApi: substrateApi,
+        feeInfo,
+        // Mock sending value to get payment info
+        sendingValue: mockSendingValue,
+        sender: senderAddress,
+        recipient: recipientAddress
+      };
 
-    /**
-     * Check fee token balance after transfer.
-     * Because the balance had subtracted with existence deposit, so only need to check if it's less than 0
-     * */
-    if (feeBalanceAfterTransfer.lt(0)) {
-      return [new TransactionError(BasicTxErrorType.NOT_ENOUGH_EXISTENTIAL_DEPOSIT, t(`Insufficient balance. Deposit ${fromAsset.symbol} and try again.`))];
-    }
-    const destMinAmount = _getTokenMinAmount(toAsset);
-    // TODO: Need to update with new logic, calculate fee to claim on dest chain
-    const minSendingRequired = new BigN(destMinAmount).multipliedBy(FEE_RATE_MULTIPLIER.high);
+      // TODO: calculate fee for destination chain
+      const bridgeFeeByDryRun = await dryRunXcmExtrinsicV2(xcmRequest);
+      if (!bridgeFeeByDryRun.fee) {
+        return undefined;
+      }
+      const estimatedBridgeFee = BigN(bridgeFeeByDryRun.fee).multipliedBy(FEE_RATE_MULTIPLIER.medium).toFixed(0, 1);
+      const fee = {
+        feeComponent: [{
+          feeType: SwapFeeType.NETWORK_FEE,
+          amount: estimatedBridgeFee,
+          tokenSlug: _getChainNativeTokenSlug(fromChainInfo)
+        }],
+        defaultFeeToken: _getChainNativeTokenSlug(fromChainInfo),
+        feeOptions: [_getChainNativeTokenSlug(fromChainInfo)]
+      };
+      const isBridgeNativeToken = _isNativeToken(fromTokenInfo);
+      let bnSendingValue;
+      let expectedReceive;
+      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 needEditAmount = swapXcm || xcmSwapXcm;
 
-    // Check sending token ED for receiver
-    if (bnAmount.lt(minSendingRequired)) {
-      const atLeastStr = formatNumber(minSendingRequired, _getAssetDecimals(toAsset), balanceFormatter, {
-        maxNumberFormat: _getAssetDecimals(toAsset) || 6
-      });
-      return [new TransactionError(TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, t('You must transfer at least {{amount}} {{symbol}} to keep the destination account alive', {
-        replace: {
-          amount: atLeastStr,
-          symbol: fromAsset.symbol
+      // todo: increase transfer amount when XCM local token
+      if (stepIndex === 0) {
+        expectedReceive = fromAmount;
+        bnSendingValue = BigN(fromAmount);
+        if (needEditAmount) {
+          bnSendingValue = bnSendingValue.multipliedBy(DEFAULT_EXCESS_AMOUNT_WEIGHT);
+          expectedReceive = bnSendingValue.toFixed(0, 1);
         }
-      }))];
-    }
-
-    // Check keepAlive on dest chain for receiver
-    if (!_isNativeToken(toAsset)) {
-      const toChainApi = this.chainService.getSubstrateApi(toAsset.originChain);
-
-      // TODO: Need to update, currently only support substrate xcm
-      if (!toChainApi) {
-        return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR, t('Destination chain is not active'))];
-      }
-      const isSendingTokenSufficient = await _isSufficientToken(toAsset, toChainApi);
-      if (!isSendingTokenSufficient) {
-        const toChainNativeAssetBalance = await this.balanceService.getTotalBalance(receiver, toAsset.originChain, toChainNativeAsset.slug, ExtrinsicType.TRANSFER_BALANCE);
-        const isReceiverAliveByNativeToken = _isAccountActive(toChainNativeAssetBalance.metadata);
-        if (!isReceiverAliveByNativeToken) {
-          // TODO: Update message
-          return [new TransactionError(TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, 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: toChainNativeAssetBalance.value,
-              nativeSymbol: toChainNativeAsset.symbol,
-              localSymbol: toAsset.symbol
-            }
-          }))];
+        if (isBridgeNativeToken) {
+          bnSendingValue = bnSendingValue.plus(BigN(estimatedBridgeFee));
+        } else {
+          bnSendingValue = bnSendingValue.plus(BigN(_getTokenMinAmount(toTokenInfo)).multipliedBy(FEE_RATE_MULTIPLIER.medium)).plus(_getTokenMinAmount(toTokenInfo));
+        }
+        if (BigN(toTokenBalance.value).lte(0)) {
+          bnSendingValue = bnSendingValue.plus(_getTokenMinAmount(toTokenInfo));
         }
+      } else {
+        // bridge after swap
+        expectedReceive = selectedQuote.toAmount;
+        if (needEditAmount) {
+          bnSendingValue = BigN(selectedQuote.toAmount).multipliedBy(DEFAULT_EXCESS_AMOUNT_WEIGHT); // need to round
+        } else {
+          bnSendingValue = BigN(selectedQuote.toAmount);
+        }
+      }
+      if (toTokenInfo.originChain === 'mythos' && _isNativeToken(toTokenInfo)) {
+        bnSendingValue = bnSendingValue.plus(BigN(2.5).shiftedBy(_getAssetDecimals(toTokenInfo)));
       }
+      const step = {
+        // @ts-ignore
+        metadata: {
+          sendingValue: bnSendingValue.toFixed(0, 1),
+          expectedReceive,
+          originTokenInfo: fromTokenInfo,
+          destinationTokenInfo: toTokenInfo,
+          receiver: recipientAddress,
+          sender: senderAddress
+        },
+        name: `Transfer ${fromTokenInfo.symbol} from ${fromChainInfo.name}`,
+        type: CommonStepType.XCM
+      };
+      return [step, fee];
+    } catch (e) {
+      console.error('Error creating xcm step', e);
+      return undefined;
     }
-
-    // SKIP: BECAUSE CURRENTLY NOT SUPPORT SNOWBRIDGE FOR SWAP FEATURE
-    // check native token ED on dest chain for receiver
-    // const bnKeepAliveBalance = _isNativeToken(destinationTokenInfo) ? new BigN(receiverNativeBalance).plus(sendingAmount) : new BigN(receiverNativeBalance);
-    //
-    // if (isSnowBridge && bnKeepAliveBalance.lt(_getChainExistentialDeposit(destChainInfo))) {
-    //   const { decimals, symbol } = _getChainNativeTokenBasicInfo(destChainInfo);
-    //   const atLeastStr = formatNumber(_getChainExistentialDeposit(destChainInfo), decimals || 0, balanceFormatter, { maxNumberFormat: 6 });
-    //
-    //   error = new TransactionError(TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, t(' Insufficient {{symbol}} on {{chain}} to cover min balance ({{amount}} {{symbol}})', { replace: { amount: atLeastStr, symbol, chain: destChainInfo.name } }));
-    // }
-
-    return [];
   }
-  async validateTokenApproveStep(params, stepIndex) {
-    return Promise.resolve([]);
+  async handleBridgeStep(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.feeService.subscribeChainFee(getId(), originAsset.originChain, 'substrate');
+    const xcmRequest = {
+      originTokenInfo: originAsset,
+      destinationTokenInfo: destinationAsset,
+      sendingValue: briefXcmStep.sendingValue,
+      recipient: briefXcmStep.receiver,
+      substrateApi: chainApi,
+      sender: briefXcmStep.sender,
+      destinationChain,
+      originChain,
+      feeInfo
+    };
+    const extrinsic = await createXcmExtrinsicV2(xcmRequest);
+    if (!extrinsic) {
+      throw new Error('XCM extrinsic error');
+    }
+    const xcmData = {
+      originNetworkKey: originAsset.originChain,
+      destinationNetworkKey: destinationAsset.originChain,
+      from: briefXcmStep.sender,
+      to: briefXcmStep.receiver,
+      value: briefXcmStep.sendingValue,
+      tokenSlug: originAsset.slug,
+      showExtraWarning: true
+    };
+    return {
+      txChain: originAsset.originChain,
+      extrinsic,
+      transferNativeAmount: _isNativeToken(originAsset) ? briefXcmStep.sendingValue : '0',
+      extrinsicType: ExtrinsicType.TRANSFER_XCM,
+      chainType: ChainType.SUBSTRATE,
+      txData: xcmData
+    };
   }
   async validateSetFeeTokenStep(params, stepIndex) {
     if (!params.selectedQuote) {
@@ -245,46 +244,6 @@ export class SwapBaseHandler {
     }
     return [];
   }
-  async validateSwapStep(params, isXcmOk, stepIndex) {
-    // check swap quote timestamp
-    // check balance to pay transaction fee
-    // check balance against spending amount
-    if (!params.selectedQuote) {
-      return Promise.resolve([new TransactionError(BasicTxErrorType.INTERNAL_ERROR)]);
-    }
-    const selectedQuote = params.selectedQuote;
-    const currentTimestamp = +Date.now();
-    if (selectedQuote.aliveUntil <= currentTimestamp) {
-      return Promise.resolve([new TransactionError(SwapErrorType.QUOTE_TIMEOUT)]);
-    }
-    const stepFee = params.process.totalFee[stepIndex].feeComponent;
-    const networkFee = stepFee.find(fee => fee.feeType === SwapFeeType.NETWORK_FEE);
-    if (!networkFee) {
-      return Promise.resolve([new TransactionError(BasicTxErrorType.INTERNAL_ERROR)]);
-    }
-    const fromAsset = this.chainService.getAssetBySlug(params.selectedQuote.pair.from);
-    const feeTokenInfo = this.chainService.getAssetBySlug(networkFee.tokenSlug);
-    const feeTokenChain = this.chainService.getChainInfoByKey(feeTokenInfo.originChain);
-    const {
-      fromAmount,
-      minSwap
-    } = params.selectedQuote;
-    const [feeTokenBalance, fromAssetBalance] = await Promise.all([this.balanceService.getTransferableBalance(params.address, feeTokenInfo.originChain, feeTokenInfo.slug), this.balanceService.getTransferableBalance(params.address, fromAsset.originChain, fromAsset.slug)]);
-    const balanceError = _validateBalanceToSwap(fromAsset, feeTokenInfo, feeTokenChain, networkFee.amount, fromAssetBalance.value, feeTokenBalance.value, fromAmount, isXcmOk, minSwap);
-    if (balanceError) {
-      return Promise.resolve([balanceError]);
-    }
-    if (!params.recipient) {
-      return Promise.resolve([]);
-    }
-    const toAsset = this.chainService.getAssetBySlug(params.selectedQuote.pair.to);
-    const toAssetChain = this.chainService.getChainInfoByKey(toAsset.originChain);
-    const recipientError = _validateSwapRecipient(toAssetChain, params.recipient);
-    if (recipientError) {
-      return Promise.resolve([recipientError]);
-    }
-    return Promise.resolve([]);
-  }
   async validateBridgeStep(receiver, fromToken, toToken, selectedFeeToken, toChainNativeToken, bnBridgeAmount, bnFromTokenBalance, bnBridgeFeeAmount, bnFeeTokenBalance, bnBridgeDeliveryFee) {
     const minBridgeAmountRequired = new BigN(_getTokenMinAmount(toToken)).multipliedBy(FEE_RATE_MULTIPLIER.high);
     const spendingAndFeePaymentValidation = validateSpendingAndFeePayment(fromToken, selectedFeeToken, bnBridgeAmount, bnFromTokenBalance, bnBridgeFeeAmount, bnFeeTokenBalance);
@@ -305,12 +264,13 @@ export class SwapBaseHandler {
 
     // 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(BasicTxErrorType.INTERNAL_ERROR)];
     }
 
     // Only need to check if account is alive with the receiving toToken
-    const isToTokenSufficient = await _isSufficientToken(toToken, toChainApi);
+    const isToTokenSufficient = await _isSufficientToken(toToken, toChainApi, sufficientChain);
     if (!isToTokenSufficient && !_isNativeToken(toToken)) {
       // sending token cannot keep account alive, must check with native token
       const toChainNativeTokenBalance = await this.balanceService.getTotalBalance(receiver, toToken.originChain, toChainNativeToken.slug, ExtrinsicType.TRANSFER_BALANCE);
@@ -356,7 +316,7 @@ export class SwapBaseHandler {
     const swapStepInfo = params.process.steps[swapIndex];
     const swapMetadata = swapStepInfo.metadata; // todo
     const swapFee = params.process.totalFee[swapIndex];
-    if (!swapMetadata || !swapMetadata.destinationTokenInfo || !swapMetadata.originTokenInfo || !swapMetadata.sendingValue) {
+    if (!swapMetadata || !swapMetadata.destinationTokenInfo || !swapMetadata.originTokenInfo || !swapMetadata.sendingValue || !swapMetadata.expectedReceive) {
       return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
     }
 
@@ -367,30 +327,33 @@ export class SwapBaseHandler {
     if (params.selectedQuote.aliveUntil <= +Date.now()) {
       return [new TransactionError(SwapErrorType.QUOTE_TIMEOUT)];
     }
+    if (params.selectedQuote.toAmount !== swapMetadata.expectedReceive) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
     const swapNetworkFee = swapFee.feeComponent.find(fee => fee.feeType === SwapFeeType.NETWORK_FEE);
     if (!swapNetworkFee) {
       return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
     }
     const swapToken = swapMetadata.originTokenInfo;
     const swapReceivingToken = swapMetadata.destinationTokenInfo;
-    const bnSwapReceivingAmount = BigN(params.selectedQuote.toAmount);
+    const bnSwapReceivingAmount = BigN(swapMetadata.expectedReceive);
     const bnSwapValue = BigN(swapMetadata.sendingValue);
     const bnSwapFeeAmount = BigN(swapNetworkFee.amount);
     const swapFeeToken = this.chainService.getAssetBySlug(swapFee.selectedFeeToken || swapFee.defaultFeeToken);
     const swapToChain = this.chainService.getChainInfoByKey(swapMetadata.destinationTokenInfo.originChain);
-    const [swapFeeTokenBalance, swapFromTokenBalance] = await Promise.all([this.balanceService.getTransferableBalance(params.address, swapFeeToken.originChain, swapFeeToken.slug, ExtrinsicType.SWAP), this.balanceService.getTransferableBalance(params.address, swapToken.originChain, swapToken.slug, ExtrinsicType.SWAP)]);
+    const [swapFeeTokenBalance, swapFromTokenBalance] = await Promise.all([this.balanceService.getTransferableBalance(swapMetadata.sender, swapFeeToken.originChain, swapFeeToken.slug, ExtrinsicType.SWAP), this.balanceService.getTransferableBalance(swapMetadata.sender, swapToken.originChain, swapToken.slug, ExtrinsicType.SWAP)]);
     const bnSwapFromTokenBalance = BigN(swapFromTokenBalance.value);
     const bnSwapFeeTokenBalance = BigN(swapFeeTokenBalance.value);
-    return this.validateSwapStepV2(swapToChain, swapToken, swapReceivingToken, swapFeeToken, bnSwapValue, bnSwapReceivingAmount, bnSwapFromTokenBalance, bnSwapFeeAmount, bnSwapFeeTokenBalance, params.recipient);
+    return this.validateSwapStepV2(swapToChain, swapToken, swapReceivingToken, swapFeeToken, bnSwapValue, bnSwapReceivingAmount, bnSwapFromTokenBalance, bnSwapFeeAmount, bnSwapFeeTokenBalance, swapMetadata.receiver);
   }
   async validateXcmSwapProcess(params, swapIndex, xcmIndex) {
-    var _currentFee$feeCompon2, _params$recipient2;
+    var _currentFee$feeCompon, _xcmMetadata$receiver;
     // Bridge
     const currentStep = params.process.steps[xcmIndex];
     const xcmMetadata = currentStep.metadata;
     const currentFee = params.process.totalFee[xcmIndex];
-    const bridgeFeeAmount = (_currentFee$feeCompon2 = currentFee.feeComponent.find(fee => fee.feeType === SwapFeeType.NETWORK_FEE)) === null || _currentFee$feeCompon2 === void 0 ? void 0 : _currentFee$feeCompon2.amount;
-    if (!xcmMetadata || !xcmMetadata.destinationTokenInfo || !xcmMetadata.originTokenInfo || !xcmMetadata.sendingValue) {
+    const bridgeFeeAmount = (_currentFee$feeCompon = currentFee.feeComponent.find(fee => fee.feeType === SwapFeeType.NETWORK_FEE)) === null || _currentFee$feeCompon === void 0 ? void 0 : _currentFee$feeCompon.amount;
+    if (!xcmMetadata || !xcmMetadata.destinationTokenInfo || !xcmMetadata.originTokenInfo || !xcmMetadata.sendingValue || !xcmMetadata.expectedReceive) {
       return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
     }
     if (!bridgeFeeAmount) {
@@ -409,8 +372,8 @@ export class SwapBaseHandler {
     const bridgeSelectedFeeToken = this.chainService.getAssetBySlug(currentFee.selectedFeeToken || currentFee.defaultFeeToken);
     const bnBridgeDeliveryFee = BigN(0); // todo
 
-    const bridgeSender = _reformatAddressWithChain(params.address, this.chainService.getChainInfoByKey(bridgeFromToken.originChain));
-    const bridgeReceiver = _reformatAddressWithChain((_params$recipient2 = params.recipient) !== null && _params$recipient2 !== void 0 ? _params$recipient2 : bridgeSender, this.chainService.getChainInfoByKey(bridgeToToken.originChain));
+    const bridgeSender = _reformatAddressWithChain(xcmMetadata.sender, this.chainService.getChainInfoByKey(bridgeFromToken.originChain));
+    const bridgeReceiver = _reformatAddressWithChain((_xcmMetadata$receiver = xcmMetadata.receiver) !== null && _xcmMetadata$receiver !== void 0 ? _xcmMetadata$receiver : bridgeSender, this.chainService.getChainInfoByKey(bridgeToToken.originChain));
     const [bridgeFromTokenBalance, bridgeFeeTokenBalance] = await Promise.all([this.balanceService.getTransferableBalance(bridgeSender, bridgeFromToken.originChain, bridgeFromToken.slug, ExtrinsicType.TRANSFER_XCM), this.balanceService.getTransferableBalance(bridgeSender, bridgeFromToken.originChain, bridgeSelectedFeeToken.slug, ExtrinsicType.TRANSFER_XCM)]);
 
     // Native token balance has already accounted for ED aka strict mode
@@ -425,7 +388,10 @@ export class SwapBaseHandler {
     const swapStepInfo = params.process.steps[swapIndex];
     const swapMetadata = swapStepInfo.metadata; // todo
     const swapFee = params.process.totalFee[swapIndex];
-    if (!swapMetadata || !swapMetadata.destinationTokenInfo || !swapMetadata.originTokenInfo || !swapMetadata.sendingValue) {
+    if (swapStepInfo.type !== SwapStepType.SWAP) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (!swapMetadata || !swapMetadata.destinationTokenInfo || !swapMetadata.originTokenInfo || !swapMetadata.sendingValue || !swapMetadata.expectedReceive) {
       return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
     }
 
@@ -459,13 +425,222 @@ export class SwapBaseHandler {
     }
     const swapFeeToken = this.chainService.getAssetBySlug(swapFee.selectedFeeToken || swapFee.defaultFeeToken);
     const swapToChain = this.chainService.getChainInfoByKey(swapMetadata.destinationTokenInfo.originChain);
-    const [swapFeeTokenBalance, swapFromTokenBalance] = await Promise.all([this.balanceService.getTransferableBalance(params.address, swapFeeToken.originChain, swapFeeToken.slug, ExtrinsicType.SWAP), this.balanceService.getTransferableBalance(params.address, swapToken.originChain, swapToken.slug, ExtrinsicType.SWAP)]);
+    const [swapFeeTokenBalance, swapFromTokenBalance] = await Promise.all([this.balanceService.getTransferableBalance(swapMetadata.sender, swapFeeToken.originChain, swapFeeToken.slug, ExtrinsicType.SWAP), this.balanceService.getTransferableBalance(swapMetadata.sender, swapToken.originChain, swapToken.slug, ExtrinsicType.SWAP)]);
+    const bnSwapFromTokenBalance = BigN(swapFromTokenBalance.value).plus(bnBridgeAmount);
+    const bnSwapFeeTokenBalance = BigN(swapFeeTokenBalance.value);
+    const swapStepValidation = this.validateSwapStepV2(swapToChain, swapToken, swapReceivingToken, swapFeeToken, bnSwapValue, bnSwapReceivingAmount, bnSwapFromTokenBalance, bnSwapFeeAmount, bnSwapFeeTokenBalance, swapMetadata.receiver);
+    if (swapStepValidation.length > 0) {
+      return swapStepValidation;
+    }
+    return [];
+  }
+  async validateSwapXcmProcess(params, swapIndex, xcmIndex) {
+    var _currentFee$feeCompon2, _xcmMetadata$receiver2;
+    // Swap
+    const swapStepInfo = params.process.steps[swapIndex];
+    const swapMetadata = swapStepInfo.metadata; // todo
+    const swapFee = params.process.totalFee[swapIndex];
+    if (!swapMetadata || !swapMetadata.destinationTokenInfo || !swapMetadata.originTokenInfo || !swapMetadata.sendingValue || !swapMetadata.expectedReceive) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+
+    // Validate quote
+    if (!params.selectedQuote) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (params.selectedQuote.aliveUntil <= +Date.now()) {
+      return [new TransactionError(SwapErrorType.QUOTE_TIMEOUT)];
+    }
+    const swapNetworkFee = swapFee.feeComponent.find(fee => fee.feeType === SwapFeeType.NETWORK_FEE);
+    if (!swapNetworkFee) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    const swapToken = swapMetadata.originTokenInfo;
+    const swapReceivingToken = swapMetadata.destinationTokenInfo;
+    const bnSwapReceivingAmount = BigN(swapMetadata.expectedReceive);
+    const bnSwapValue = BigN(swapMetadata.sendingValue);
+    const bnSwapFeeAmount = BigN(swapNetworkFee.amount);
+    if (bnSwapValue.lte(_getTokenMinAmount(swapToken))) {
+      const atLeastString = formatNumber(_getTokenMinAmount(swapToken), _getAssetDecimals(swapToken), balanceFormatter, {
+        maxNumberFormat: _getAssetDecimals(swapToken) || 6
+      });
+      return [new TransactionError(SwapErrorType.NOT_MEET_MIN_SWAP, t(`Swap amount too small. Increase to more than ${atLeastString} ${_getAssetSymbol(swapToken)} and try again`))];
+    }
+    const swapFeeToken = this.chainService.getAssetBySlug(swapFee.selectedFeeToken || swapFee.defaultFeeToken);
+    const swapToChain = this.chainService.getChainInfoByKey(swapMetadata.destinationTokenInfo.originChain);
+    const [swapFeeTokenBalance, swapFromTokenBalance] = await Promise.all([this.balanceService.getTransferableBalance(swapMetadata.sender, swapFeeToken.originChain, swapFeeToken.slug, ExtrinsicType.SWAP), this.balanceService.getTransferableBalance(swapMetadata.sender, swapToken.originChain, swapToken.slug, ExtrinsicType.SWAP)]);
+    const bnSwapFromTokenBalance = BigN(swapFromTokenBalance.value);
+    const bnSwapFeeTokenBalance = BigN(swapFeeTokenBalance.value);
+    const swapStepValidation = this.validateSwapStepV2(swapToChain, swapToken, swapReceivingToken, swapFeeToken, bnSwapValue, bnSwapReceivingAmount, bnSwapFromTokenBalance, bnSwapFeeAmount, bnSwapFeeTokenBalance, swapMetadata.receiver);
+    if (swapStepValidation.length > 0) {
+      return swapStepValidation;
+    }
+
+    // Bridge
+    const currentStep = params.process.steps[xcmIndex];
+    const xcmMetadata = currentStep.metadata;
+    const currentFee = params.process.totalFee[xcmIndex];
+    const bridgeFeeAmount = (_currentFee$feeCompon2 = currentFee.feeComponent.find(fee => fee.feeType === SwapFeeType.NETWORK_FEE)) === null || _currentFee$feeCompon2 === void 0 ? void 0 : _currentFee$feeCompon2.amount;
+    if (!xcmMetadata || !xcmMetadata.destinationTokenInfo || !xcmMetadata.originTokenInfo || !xcmMetadata.sendingValue || !xcmMetadata.expectedReceive) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (!bridgeFeeAmount) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    const bridgeFromToken = xcmMetadata.originTokenInfo;
+    const bridgeToToken = xcmMetadata.destinationTokenInfo;
+    const fromChain = this.chainService.getChainInfoByKey(bridgeFromToken.originChain);
+    const toChain = this.chainService.getChainInfoByKey(bridgeToToken.originChain);
+    if (swapReceivingToken.slug !== bridgeFromToken.slug) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (_isSnowBridgeXcm(fromChain, toChain)) {
+      return [new TransactionError(BasicTxErrorType.UNSUPPORTED)];
+    }
+    const bnBridgeFeeAmount = BigN(bridgeFeeAmount);
+    const bnBridgeAmount = new BigN(xcmMetadata.sendingValue);
+    const bridgeToChainNativeToken = this.chainService.getNativeTokenInfo(bridgeToToken.originChain);
+    const bridgeSelectedFeeToken = this.chainService.getAssetBySlug(currentFee.selectedFeeToken || currentFee.defaultFeeToken);
+    const bnBridgeDeliveryFee = BigN(0); // todo
+
+    const bridgeSender = _reformatAddressWithChain(xcmMetadata.sender, this.chainService.getChainInfoByKey(bridgeFromToken.originChain));
+    const bridgeReceiver = _reformatAddressWithChain((_xcmMetadata$receiver2 = xcmMetadata.receiver) !== null && _xcmMetadata$receiver2 !== void 0 ? _xcmMetadata$receiver2 : bridgeSender, this.chainService.getChainInfoByKey(bridgeToToken.originChain));
+    const [bridgeFromTokenBalance, bridgeFeeTokenBalance] = await Promise.all([this.balanceService.getTransferableBalance(bridgeSender, bridgeFromToken.originChain, bridgeFromToken.slug, ExtrinsicType.TRANSFER_XCM), this.balanceService.getTransferableBalance(bridgeSender, bridgeFromToken.originChain, bridgeSelectedFeeToken.slug, ExtrinsicType.TRANSFER_XCM)]);
+
+    // Native token balance has already accounted for ED aka strict mode
+    const bnBridgeFromTokenBalance = new BigN(bridgeFromTokenBalance.value).plus(bnSwapReceivingAmount);
+    const bnBridgeFeeTokenBalance = new BigN(bridgeFeeTokenBalance.value);
+    const bridgeStepValidation = await this.validateBridgeStep(bridgeReceiver, bridgeFromToken, bridgeToToken, bridgeSelectedFeeToken, bridgeToChainNativeToken, bnBridgeAmount, bnBridgeFromTokenBalance, bnBridgeFeeAmount, bnBridgeFeeTokenBalance, bnBridgeDeliveryFee);
+    if (bridgeStepValidation.length > 0) {
+      return bridgeStepValidation;
+    }
+    return [];
+  }
+  async validateXcmSwapXcmProcess(params, swapIndex, xcmIndex, transitIndex) {
+    var _bridgeFee$feeCompone, _bridgeMetadata$recei, _transitTotalFee$feeC, _transitMetadata$rece;
+    // Bridge
+    const bridgeStep = params.process.steps[xcmIndex];
+    const bridgeMetadata = bridgeStep.metadata;
+    const bridgeFee = params.process.totalFee[xcmIndex];
+    const bridgeFeeAmount = (_bridgeFee$feeCompone = bridgeFee.feeComponent.find(fee => fee.feeType === SwapFeeType.NETWORK_FEE)) === null || _bridgeFee$feeCompone === void 0 ? void 0 : _bridgeFee$feeCompone.amount;
+    if (!bridgeMetadata || !bridgeMetadata.destinationTokenInfo || !bridgeMetadata.originTokenInfo || !bridgeMetadata.sendingValue || !bridgeMetadata.expectedReceive) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (!bridgeFeeAmount) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    const bridgeFromToken = bridgeMetadata.originTokenInfo;
+    const bridgeToToken = bridgeMetadata.destinationTokenInfo;
+    const fromChain = this.chainService.getChainInfoByKey(bridgeFromToken.originChain);
+    const toChain = this.chainService.getChainInfoByKey(bridgeToToken.originChain);
+    if (_isSnowBridgeXcm(fromChain, toChain)) {
+      return [new TransactionError(BasicTxErrorType.UNSUPPORTED)];
+    }
+    const bnBridgeFeeAmount = BigN(bridgeFeeAmount);
+    const bnBridgeAmount = new BigN(bridgeMetadata.sendingValue);
+    const bridgeToChainNativeToken = this.chainService.getNativeTokenInfo(bridgeToToken.originChain);
+    const bridgeSelectedFeeToken = this.chainService.getAssetBySlug(bridgeFee.selectedFeeToken || bridgeFee.defaultFeeToken);
+    const bnBridgeDeliveryFee = BigN(0); // todo
+
+    const bridgeSender = _reformatAddressWithChain(bridgeMetadata.sender, this.chainService.getChainInfoByKey(bridgeFromToken.originChain));
+    const bridgeReceiver = _reformatAddressWithChain((_bridgeMetadata$recei = bridgeMetadata.receiver) !== null && _bridgeMetadata$recei !== void 0 ? _bridgeMetadata$recei : bridgeSender, this.chainService.getChainInfoByKey(bridgeToToken.originChain));
+    const [bridgeFromTokenBalance, bridgeFeeTokenBalance] = await Promise.all([this.balanceService.getTransferableBalance(bridgeSender, bridgeFromToken.originChain, bridgeFromToken.slug, ExtrinsicType.TRANSFER_XCM), this.balanceService.getTransferableBalance(bridgeSender, bridgeFromToken.originChain, bridgeSelectedFeeToken.slug, ExtrinsicType.TRANSFER_XCM)]);
+
+    // Native token balance has already accounted for ED aka strict mode
+    const bnBridgeFromTokenBalance = new BigN(bridgeFromTokenBalance.value);
+    const bnBridgeFeeTokenBalance = new BigN(bridgeFeeTokenBalance.value);
+    const bridgeStepValidation = await this.validateBridgeStep(bridgeReceiver, bridgeFromToken, bridgeToToken, bridgeSelectedFeeToken, bridgeToChainNativeToken, bnBridgeAmount, bnBridgeFromTokenBalance, bnBridgeFeeAmount, bnBridgeFeeTokenBalance, bnBridgeDeliveryFee);
+    if (bridgeStepValidation.length > 0) {
+      return bridgeStepValidation;
+    }
+
+    // Swap
+    const swapStepInfo = params.process.steps[swapIndex];
+    const swapMetadata = swapStepInfo.metadata; // todo
+    const swapFee = params.process.totalFee[swapIndex];
+    if (swapStepInfo.type !== SwapStepType.SWAP) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (!swapMetadata || !swapMetadata.destinationTokenInfo || !swapMetadata.originTokenInfo || !swapMetadata.sendingValue || !swapMetadata.expectedReceive) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+
+    // Validate quote
+    if (!params.selectedQuote) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (params.selectedQuote.aliveUntil <= +Date.now()) {
+      return [new TransactionError(SwapErrorType.QUOTE_TIMEOUT)];
+    }
+    const swapNetworkFee = swapFee.feeComponent.find(fee => fee.feeType === SwapFeeType.NETWORK_FEE);
+    if (!swapNetworkFee) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    const swapToken = swapMetadata.originTokenInfo;
+    const swapReceivingToken = swapMetadata.destinationTokenInfo;
+    const bnSwapReceivingAmount = BigN(swapMetadata.expectedReceive);
+    if (swapToken.slug !== bridgeToToken.slug) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    const bnSwapValue = BigN(swapMetadata.sendingValue);
+    const bnSwapFeeAmount = BigN(swapNetworkFee.amount);
+    if (bnSwapValue.gt(bnBridgeAmount)) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (bnSwapValue.lte(_getTokenMinAmount(swapToken))) {
+      const atLeastString = formatNumber(_getTokenMinAmount(swapToken), _getAssetDecimals(swapToken), balanceFormatter, {
+        maxNumberFormat: _getAssetDecimals(swapToken) || 6
+      });
+      return [new TransactionError(SwapErrorType.NOT_MEET_MIN_SWAP, t(`Swap amount too small. Increase to more than ${atLeastString} ${_getAssetSymbol(swapToken)} and try again`))];
+    }
+    const swapFeeToken = this.chainService.getAssetBySlug(swapFee.selectedFeeToken || swapFee.defaultFeeToken);
+    const swapToChain = this.chainService.getChainInfoByKey(swapMetadata.destinationTokenInfo.originChain);
+    const [swapFeeTokenBalance, swapFromTokenBalance] = await Promise.all([this.balanceService.getTransferableBalance(swapMetadata.sender, swapFeeToken.originChain, swapFeeToken.slug, ExtrinsicType.SWAP), this.balanceService.getTransferableBalance(swapMetadata.sender, swapToken.originChain, swapToken.slug, ExtrinsicType.SWAP)]);
     const bnSwapFromTokenBalance = BigN(swapFromTokenBalance.value).plus(bnBridgeAmount);
     const bnSwapFeeTokenBalance = BigN(swapFeeTokenBalance.value);
-    const swapStepValidation = this.validateSwapStepV2(swapToChain, swapToken, swapReceivingToken, swapFeeToken, bnSwapValue, bnSwapReceivingAmount, bnSwapFromTokenBalance, bnSwapFeeAmount, bnSwapFeeTokenBalance, params.recipient);
+    const swapStepValidation = this.validateSwapStepV2(swapToChain, swapToken, swapReceivingToken, swapFeeToken, bnSwapValue, bnSwapReceivingAmount, bnSwapFromTokenBalance, bnSwapFeeAmount, bnSwapFeeTokenBalance, swapMetadata.receiver);
     if (swapStepValidation.length > 0) {
       return swapStepValidation;
     }
+
+    // Bridge again
+    const transitStep = params.process.steps[transitIndex];
+    const transitMetadata = transitStep.metadata;
+    const transitTotalFee = params.process.totalFee[transitIndex];
+    const transitFee = (_transitTotalFee$feeC = transitTotalFee.feeComponent.find(fee => fee.feeType === SwapFeeType.NETWORK_FEE)) === null || _transitTotalFee$feeC === void 0 ? void 0 : _transitTotalFee$feeC.amount;
+    if (!transitMetadata || !transitMetadata.destinationTokenInfo || !transitMetadata.originTokenInfo || !transitMetadata.sendingValue || !transitMetadata.expectedReceive) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (!transitFee) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    const transitFromToken = transitMetadata.originTokenInfo;
+    const transitToToken = transitMetadata.destinationTokenInfo;
+    const fromTransitChain = this.chainService.getChainInfoByKey(transitFromToken.originChain);
+    const toTransitChain = this.chainService.getChainInfoByKey(transitToToken.originChain);
+    if (swapReceivingToken.slug !== transitFromToken.slug) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (_isSnowBridgeXcm(fromTransitChain, toTransitChain)) {
+      return [new TransactionError(BasicTxErrorType.UNSUPPORTED)];
+    }
+    const bnTransitFeeAmount = BigN(transitFee);
+    const bnTransitAmount = new BigN(transitMetadata.sendingValue);
+    const transitToChainNativeToken = this.chainService.getNativeTokenInfo(transitToToken.originChain);
+    const transitSelectedFeeToken = this.chainService.getAssetBySlug(transitTotalFee.selectedFeeToken || transitTotalFee.defaultFeeToken);
+    const bnTransitDeliveryFee = BigN(0); // todo
+
+    const transitSender = _reformatAddressWithChain(transitMetadata.sender, this.chainService.getChainInfoByKey(transitFromToken.originChain));
+    const transitReceiver = _reformatAddressWithChain((_transitMetadata$rece = transitMetadata.receiver) !== null && _transitMetadata$rece !== void 0 ? _transitMetadata$rece : transitSender, this.chainService.getChainInfoByKey(transitToToken.originChain));
+    const [transitFromTokenBalance, transitFeeTokenBalance] = await Promise.all([this.balanceService.getTransferableBalance(transitSender, transitFromToken.originChain, transitFromToken.slug, ExtrinsicType.TRANSFER_XCM), this.balanceService.getTransferableBalance(transitSender, transitFromToken.originChain, transitSelectedFeeToken.slug, ExtrinsicType.TRANSFER_XCM)]);
+
+    // Native token balance has already accounted for ED aka strict mode
+    const bnTransitFromTokenBalance = new BigN(transitFromTokenBalance.value).plus(bnSwapReceivingAmount);
+    const bnTransitFeeTokenBalance = new BigN(transitFeeTokenBalance.value);
+    const transitStepValidation = await this.validateBridgeStep(transitReceiver, transitFromToken, transitToToken, transitSelectedFeeToken, transitToChainNativeToken, bnTransitAmount, bnTransitFromTokenBalance, bnTransitFeeAmount, bnTransitFeeTokenBalance, bnTransitDeliveryFee);
+    if (transitStepValidation.length > 0) {
+      return transitStepValidation;
+    }
     return [];
   }
   get name() {