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

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

@@ -8,16 +8,17 @@ exports.SwapBaseHandler = 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 _swap = require("@subwallet/extension-base/core/logic-validation/swap");
 var _systemPallet = require("@subwallet/extension-base/core/substrate/system-pallet");
 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 _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");
 var _serviceBase = require("@subwallet/extension-base/types/service-base");
-var _swap2 = require("@subwallet/extension-base/types/swap");
+var _swap = require("@subwallet/extension-base/types/swap");
 var _utils4 = require("@subwallet/extension-base/utils");
+var _getId = require("@subwallet/extension-base/utils/getId");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 var _i18next = require("i18next");
 var _utilCrypto = require("@polkadot/util-crypto");
@@ -39,30 +40,6 @@ class SwapBaseHandler {
     this.balanceService = balanceService;
     this.feeService = feeService;
   }
-
-  // public abstract getSwapQuote(request: SwapRequest): Promise<SwapQuote | SwapError>;
-  async generateOptimalProcess(params, genStepFuncList) {
-    const result = {
-      totalFee: [_serviceBase.MOCK_STEP_FEE],
-      steps: [_serviceBase.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: [_serviceBase.MOCK_STEP_FEE],
@@ -70,8 +47,8 @@ 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,
@@ -85,158 +62,180 @@ class SwapBaseHandler {
       return result;
     }
   }
-  async validateXcmStep(params, stepIndex) {
-    const bnAmount = new _bignumber.default(params.selectedQuote.fromAmount);
-    const swapPair = params.selectedQuote.pair;
-    const alternativeAssetSlug = (0, _utils3.getSwapAlternativeAsset)(swapPair);
-    if (!alternativeAssetSlug) {
-      return [new _TransactionError.TransactionError(_types.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 !== _swap.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 = (0, _utils4._reformatAddressWithChain)(address, fromChainInfo);
+    if (stepIndex === 0) {
+      recipientAddress = (0, _utils4._reformatAddressWithChain)(address, toChainInfo);
+    } else {
+      // bridge after swap
+      recipientAddress = (0, _utils4._reformatAddressWithChain)(recipient || address, toChainInfo);
+    }
+    if (!(0, _xcmParser._isXcmWithinSameConsensus)(fromChainInfo, toChainInfo) || (0, _xcmParser._isSnowBridgeXcm)(fromChainInfo, toChainInfo) || (0, _xcmParser._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 _bignumber.default(alternativeAssetBalance.value);
-    const bnFromAssetBalance = new _bignumber.default(fromAssetBalance.value);
-    const xcmFeeComponent = params.process.totalFee[stepIndex].feeComponent[0]; // todo: can do better than indexing
-    const xcmFee = new _bignumber.default(xcmFeeComponent.amount || '0');
-    let xcmAmount = bnAmount.minus(bnFromAssetBalance);
-    let editedXcmFee = new _bignumber.default(0);
-    if ((0, _utils2._isNativeToken)(alternativeAsset)) {
-      xcmAmount = xcmAmount.plus(xcmFee);
-      editedXcmFee = xcmFee.times(2);
-    }
-    if (!bnAlternativeAssetBalance.minus((0, _utils2._isNativeToken)(alternativeAsset) ? xcmAmount.plus(xcmFee) : xcmFee).gt(0)) {
-      const maxBn = bnFromAssetBalance.plus(new _bignumber.default(alternativeAssetBalance.value)).minus((0, _utils2._isNativeToken)(alternativeAsset) ? editedXcmFee : xcmFee);
-      const maxValue = (0, _utils4.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 = (0, _utils4.formatNumber)(bnFromAssetBalance.toString(), fromAsset.decimals || 0);
-      const bnMaxXCM = new _bignumber.default(alternativeAssetBalance.value).minus((0, _utils2._isNativeToken)(alternativeAsset) ? editedXcmFee : xcmFee);
-      const maxXCMValue = (0, _utils4.formatNumber)(bnMaxXCM.toString(), fromAsset.decimals || 0);
-      if (maxBn.lte(0) || bnFromAssetBalance.lte(0) || bnMaxXCM.lte(0)) {
-        return [new _TransactionError.TransactionError(_types.BasicTxErrorType.NOT_ENOUGH_BALANCE, (0, _i18next.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.TransactionError(_types.BasicTxErrorType.NOT_ENOUGH_BALANCE, (0, _i18next.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 === _swap2.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 _bignumber.default(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.TransactionError(_types.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 = (0, _utils4._reformatAddressWithChain)(params.address, fromChain);
-    const receiver = (0, _utils4._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, _KoniTypes.ExtrinsicType.TRANSFER_XCM), this.balanceService.getTransferableBalance(sender, fromAsset.originChain, feeToken, _KoniTypes.ExtrinsicType.TRANSFER_XCM)]);
-    const bnFromAssetBalance = new _bignumber.default(fromAssetBalance.value);
-    const bnFeeTokenBalance = new _bignumber.default(feeTokenBalance.value);
-
-    /* Compare transferable balance with amount xcm */
-    if (bnFromAssetBalance.lt(bnAmount)) {
-      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.NOT_ENOUGH_BALANCE, (0, _i18next.t)(`Insufficient balance. Deposit ${fromAsset.symbol} and try again.`))];
-    }
+      const substrateApi = await this.chainService.getSubstrateApi(fromTokenInfo.originChain).isReady;
+      const id = (0, _getId.getId)();
+      const [feeInfo, toTokenBalance] = await Promise.all([this.feeService.subscribeChainFee(id, fromTokenInfo.originChain, 'substrate'), this.balanceService.getTotalBalance(senderAddress, toTokenInfo.originChain, toTokenInfo.slug, _KoniTypes.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
+      };
 
-    /**
-     * 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);
-
-    /**
-     * 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.TransactionError(_types.BasicTxErrorType.NOT_ENOUGH_EXISTENTIAL_DEPOSIT, (0, _i18next.t)(`Insufficient balance. Deposit ${fromAsset.symbol} and try again.`))];
-    }
-    const destMinAmount = (0, _utils2._getTokenMinAmount)(toAsset);
-    // TODO: Need to update with new logic, calculate fee to claim on dest chain
-    const minSendingRequired = new _bignumber.default(destMinAmount).multipliedBy(_utils3.FEE_RATE_MULTIPLIER.high);
+      // TODO: calculate fee for destination chain
+      const bridgeFeeByDryRun = await (0, _xcm.dryRunXcmExtrinsicV2)(xcmRequest);
+      if (!bridgeFeeByDryRun.fee) {
+        return undefined;
+      }
+      const estimatedBridgeFee = (0, _bignumber.default)(bridgeFeeByDryRun.fee).multipliedBy(_utils3.FEE_RATE_MULTIPLIER.medium).toFixed(0, 1);
+      const fee = {
+        feeComponent: [{
+          feeType: _swap.SwapFeeType.NETWORK_FEE,
+          amount: estimatedBridgeFee,
+          tokenSlug: (0, _utils2._getChainNativeTokenSlug)(fromChainInfo)
+        }],
+        defaultFeeToken: (0, _utils2._getChainNativeTokenSlug)(fromChainInfo),
+        feeOptions: [(0, _utils2._getChainNativeTokenSlug)(fromChainInfo)]
+      };
+      const isBridgeNativeToken = (0, _utils2._isNativeToken)(fromTokenInfo);
+      let bnSendingValue;
+      let expectedReceive;
+      const actionList = JSON.stringify(path.map(step => step.action));
+      const xcmSwapXcm = actionList === JSON.stringify([_swap.DynamicSwapType.BRIDGE, _swap.DynamicSwapType.SWAP, _swap.DynamicSwapType.BRIDGE]);
+      const swapXcm = actionList === JSON.stringify([_swap.DynamicSwapType.SWAP, _swap.DynamicSwapType.BRIDGE]);
+      const needEditAmount = swapXcm || xcmSwapXcm;
 
-    // Check sending token ED for receiver
-    if (bnAmount.lt(minSendingRequired)) {
-      const atLeastStr = (0, _utils4.formatNumber)(minSendingRequired, (0, _utils2._getAssetDecimals)(toAsset), _utils4.balanceFormatter, {
-        maxNumberFormat: (0, _utils2._getAssetDecimals)(toAsset) || 6
-      });
-      return [new _TransactionError.TransactionError(_types.TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, (0, _i18next.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 = (0, _bignumber.default)(fromAmount);
+        if (needEditAmount) {
+          bnSendingValue = bnSendingValue.multipliedBy(_utils3.DEFAULT_EXCESS_AMOUNT_WEIGHT);
+          expectedReceive = bnSendingValue.toFixed(0, 1);
         }
-      }))];
-    }
-
-    // Check keepAlive on dest chain for receiver
-    if (!(0, _utils2._isNativeToken)(toAsset)) {
-      const toChainApi = this.chainService.getSubstrateApi(toAsset.originChain);
-
-      // TODO: Need to update, currently only support substrate xcm
-      if (!toChainApi) {
-        return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR, (0, _i18next.t)('Destination chain is not active'))];
-      }
-      const isSendingTokenSufficient = await (0, _utils._isSufficientToken)(toAsset, toChainApi);
-      if (!isSendingTokenSufficient) {
-        const toChainNativeAssetBalance = await this.balanceService.getTotalBalance(receiver, toAsset.originChain, toChainNativeAsset.slug, _KoniTypes.ExtrinsicType.TRANSFER_BALANCE);
-        const isReceiverAliveByNativeToken = (0, _systemPallet._isAccountActive)(toChainNativeAssetBalance.metadata);
-        if (!isReceiverAliveByNativeToken) {
-          // TODO: Update message
-          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: toChainNativeAssetBalance.value,
-              nativeSymbol: toChainNativeAsset.symbol,
-              localSymbol: toAsset.symbol
-            }
-          }))];
+        if (isBridgeNativeToken) {
+          bnSendingValue = bnSendingValue.plus((0, _bignumber.default)(estimatedBridgeFee));
+        } else {
+          bnSendingValue = bnSendingValue.plus((0, _bignumber.default)((0, _utils2._getTokenMinAmount)(toTokenInfo)).multipliedBy(_utils3.FEE_RATE_MULTIPLIER.medium)).plus((0, _utils2._getTokenMinAmount)(toTokenInfo));
         }
+        if ((0, _bignumber.default)(toTokenBalance.value).lte(0)) {
+          bnSendingValue = bnSendingValue.plus((0, _utils2._getTokenMinAmount)(toTokenInfo));
+        }
+      } else {
+        // bridge after swap
+        expectedReceive = selectedQuote.toAmount;
+        if (needEditAmount) {
+          bnSendingValue = (0, _bignumber.default)(selectedQuote.toAmount).multipliedBy(_utils3.DEFAULT_EXCESS_AMOUNT_WEIGHT); // need to round
+        } else {
+          bnSendingValue = (0, _bignumber.default)(selectedQuote.toAmount);
+        }
+      }
+      if (toTokenInfo.originChain === 'mythos' && (0, _utils2._isNativeToken)(toTokenInfo)) {
+        bnSendingValue = bnSendingValue.plus((0, _bignumber.default)(2.5).shiftedBy((0, _utils2._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: _serviceBase.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((0, _getId.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 (0, _xcm.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: (0, _utils2._isNativeToken)(originAsset) ? briefXcmStep.sendingValue : '0',
+      extrinsicType: _KoniTypes.ExtrinsicType.TRANSFER_XCM,
+      chainType: _KoniTypes.ChainType.SUBSTRATE,
+      txData: xcmData
+    };
   }
   async validateSetFeeTokenStep(params, stepIndex) {
     if (!params.selectedQuote) {
@@ -253,46 +252,6 @@ 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.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)]);
-    }
-    const selectedQuote = params.selectedQuote;
-    const currentTimestamp = +Date.now();
-    if (selectedQuote.aliveUntil <= currentTimestamp) {
-      return Promise.resolve([new _TransactionError.TransactionError(_swap2.SwapErrorType.QUOTE_TIMEOUT)]);
-    }
-    const stepFee = params.process.totalFee[stepIndex].feeComponent;
-    const networkFee = stepFee.find(fee => fee.feeType === _swap2.SwapFeeType.NETWORK_FEE);
-    if (!networkFee) {
-      return Promise.resolve([new _TransactionError.TransactionError(_types.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 = (0, _swap._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 = (0, _swap._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 _bignumber.default((0, _utils2._getTokenMinAmount)(toToken)).multipliedBy(_utils3.FEE_RATE_MULTIPLIER.high);
     const spendingAndFeePaymentValidation = (0, _logicValidation.validateSpendingAndFeePayment)(fromToken, selectedFeeToken, bnBridgeAmount, bnFromTokenBalance, bnBridgeFeeAmount, bnFeeTokenBalance);
@@ -313,12 +272,13 @@ 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.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);
+    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);
@@ -343,7 +303,7 @@ class SwapBaseHandler {
       const atLeastStr = (0, _utils4.formatNumber)((0, _utils2._getTokenMinAmount)(receivingToken), (0, _utils2._getAssetDecimals)(receivingToken), _utils4.balanceFormatter, {
         maxNumberFormat: (0, _utils2._getAssetDecimals)(receivingToken) || 6
       });
-      return [new _TransactionError.TransactionError(_swap2.SwapErrorType.NOT_MEET_MIN_SWAP, (0, _i18next.t)('You can\'t receive less than {{number}} {{symbol}}', {
+      return [new _TransactionError.TransactionError(_swap.SwapErrorType.NOT_MEET_MIN_SWAP, (0, _i18next.t)('You can\'t receive less than {{number}} {{symbol}}', {
         replace: {
           number: atLeastStr,
           symbol: (0, _utils2._getAssetSymbol)(receivingToken)
@@ -355,7 +315,7 @@ class SwapBaseHandler {
       const isEvmDestChain = (0, _utils2._isChainEvmCompatible)(swapToChain);
       if (isEvmAddress && !isEvmDestChain || !isEvmAddress && isEvmDestChain) {
         // todo: update this condition
-        return [new _TransactionError.TransactionError(_swap2.SwapErrorType.INVALID_RECIPIENT)];
+        return [new _TransactionError.TransactionError(_swap.SwapErrorType.INVALID_RECIPIENT)];
       }
     }
     return [];
@@ -364,7 +324,7 @@ 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.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
     }
 
@@ -373,32 +333,35 @@ class SwapBaseHandler {
       return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
     }
     if (params.selectedQuote.aliveUntil <= +Date.now()) {
-      return [new _TransactionError.TransactionError(_swap2.SwapErrorType.QUOTE_TIMEOUT)];
+      return [new _TransactionError.TransactionError(_swap.SwapErrorType.QUOTE_TIMEOUT)];
     }
-    const swapNetworkFee = swapFee.feeComponent.find(fee => fee.feeType === _swap2.SwapFeeType.NETWORK_FEE);
+    if (params.selectedQuote.toAmount !== swapMetadata.expectedReceive) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    const swapNetworkFee = swapFee.feeComponent.find(fee => fee.feeType === _swap.SwapFeeType.NETWORK_FEE);
     if (!swapNetworkFee) {
       return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
     }
     const swapToken = swapMetadata.originTokenInfo;
     const swapReceivingToken = swapMetadata.destinationTokenInfo;
-    const bnSwapReceivingAmount = (0, _bignumber.default)(params.selectedQuote.toAmount);
+    const bnSwapReceivingAmount = (0, _bignumber.default)(swapMetadata.expectedReceive);
     const bnSwapValue = (0, _bignumber.default)(swapMetadata.sendingValue);
     const bnSwapFeeAmount = (0, _bignumber.default)(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, _KoniTypes.ExtrinsicType.SWAP), this.balanceService.getTransferableBalance(params.address, swapToken.originChain, swapToken.slug, _KoniTypes.ExtrinsicType.SWAP)]);
+    const [swapFeeTokenBalance, swapFromTokenBalance] = await Promise.all([this.balanceService.getTransferableBalance(swapMetadata.sender, swapFeeToken.originChain, swapFeeToken.slug, _KoniTypes.ExtrinsicType.SWAP), this.balanceService.getTransferableBalance(swapMetadata.sender, swapToken.originChain, swapToken.slug, _KoniTypes.ExtrinsicType.SWAP)]);
     const bnSwapFromTokenBalance = (0, _bignumber.default)(swapFromTokenBalance.value);
     const bnSwapFeeTokenBalance = (0, _bignumber.default)(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 === _swap2.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 === _swap.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.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
     }
     if (!bridgeFeeAmount) {
@@ -417,8 +380,8 @@ class SwapBaseHandler {
     const bridgeSelectedFeeToken = this.chainService.getAssetBySlug(currentFee.selectedFeeToken || currentFee.defaultFeeToken);
     const bnBridgeDeliveryFee = (0, _bignumber.default)(0); // todo
 
-    const bridgeSender = (0, _utils4._reformatAddressWithChain)(params.address, this.chainService.getChainInfoByKey(bridgeFromToken.originChain));
-    const bridgeReceiver = (0, _utils4._reformatAddressWithChain)((_params$recipient2 = params.recipient) !== null && _params$recipient2 !== void 0 ? _params$recipient2 : bridgeSender, this.chainService.getChainInfoByKey(bridgeToToken.originChain));
+    const bridgeSender = (0, _utils4._reformatAddressWithChain)(xcmMetadata.sender, this.chainService.getChainInfoByKey(bridgeFromToken.originChain));
+    const bridgeReceiver = (0, _utils4._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, _KoniTypes.ExtrinsicType.TRANSFER_XCM), this.balanceService.getTransferableBalance(bridgeSender, bridgeFromToken.originChain, bridgeSelectedFeeToken.slug, _KoniTypes.ExtrinsicType.TRANSFER_XCM)]);
 
     // Native token balance has already accounted for ED aka strict mode
@@ -433,7 +396,10 @@ 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 !== _types.SwapStepType.SWAP) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (!swapMetadata || !swapMetadata.destinationTokenInfo || !swapMetadata.originTokenInfo || !swapMetadata.sendingValue || !swapMetadata.expectedReceive) {
       return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
     }
 
@@ -442,9 +408,9 @@ class SwapBaseHandler {
       return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
     }
     if (params.selectedQuote.aliveUntil <= +Date.now()) {
-      return [new _TransactionError.TransactionError(_swap2.SwapErrorType.QUOTE_TIMEOUT)];
+      return [new _TransactionError.TransactionError(_swap.SwapErrorType.QUOTE_TIMEOUT)];
     }
-    const swapNetworkFee = swapFee.feeComponent.find(fee => fee.feeType === _swap2.SwapFeeType.NETWORK_FEE);
+    const swapNetworkFee = swapFee.feeComponent.find(fee => fee.feeType === _swap.SwapFeeType.NETWORK_FEE);
     if (!swapNetworkFee) {
       return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
     }
@@ -463,17 +429,226 @@ class SwapBaseHandler {
       const atLeastString = (0, _utils4.formatNumber)((0, _utils2._getTokenMinAmount)(swapToken), (0, _utils2._getAssetDecimals)(swapToken), _utils4.balanceFormatter, {
         maxNumberFormat: (0, _utils2._getAssetDecimals)(swapToken) || 6
       });
-      return [new _TransactionError.TransactionError(_swap2.SwapErrorType.NOT_MEET_MIN_SWAP, (0, _i18next.t)(`Swap amount too small. Increase to more than ${atLeastString} ${(0, _utils2._getAssetSymbol)(swapToken)} and try again`))];
+      return [new _TransactionError.TransactionError(_swap.SwapErrorType.NOT_MEET_MIN_SWAP, (0, _i18next.t)(`Swap amount too small. Increase to more than ${atLeastString} ${(0, _utils2._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, _KoniTypes.ExtrinsicType.SWAP), this.balanceService.getTransferableBalance(swapMetadata.sender, swapToken.originChain, swapToken.slug, _KoniTypes.ExtrinsicType.SWAP)]);
+    const bnSwapFromTokenBalance = (0, _bignumber.default)(swapFromTokenBalance.value).plus(bnBridgeAmount);
+    const bnSwapFeeTokenBalance = (0, _bignumber.default)(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.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+
+    // Validate quote
+    if (!params.selectedQuote) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (params.selectedQuote.aliveUntil <= +Date.now()) {
+      return [new _TransactionError.TransactionError(_swap.SwapErrorType.QUOTE_TIMEOUT)];
+    }
+    const swapNetworkFee = swapFee.feeComponent.find(fee => fee.feeType === _swap.SwapFeeType.NETWORK_FEE);
+    if (!swapNetworkFee) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    const swapToken = swapMetadata.originTokenInfo;
+    const swapReceivingToken = swapMetadata.destinationTokenInfo;
+    const bnSwapReceivingAmount = (0, _bignumber.default)(swapMetadata.expectedReceive);
+    const bnSwapValue = (0, _bignumber.default)(swapMetadata.sendingValue);
+    const bnSwapFeeAmount = (0, _bignumber.default)(swapNetworkFee.amount);
+    if (bnSwapValue.lte((0, _utils2._getTokenMinAmount)(swapToken))) {
+      const atLeastString = (0, _utils4.formatNumber)((0, _utils2._getTokenMinAmount)(swapToken), (0, _utils2._getAssetDecimals)(swapToken), _utils4.balanceFormatter, {
+        maxNumberFormat: (0, _utils2._getAssetDecimals)(swapToken) || 6
+      });
+      return [new _TransactionError.TransactionError(_swap.SwapErrorType.NOT_MEET_MIN_SWAP, (0, _i18next.t)(`Swap amount too small. Increase to more than ${atLeastString} ${(0, _utils2._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, _KoniTypes.ExtrinsicType.SWAP), this.balanceService.getTransferableBalance(swapMetadata.sender, swapToken.originChain, swapToken.slug, _KoniTypes.ExtrinsicType.SWAP)]);
+    const bnSwapFromTokenBalance = (0, _bignumber.default)(swapFromTokenBalance.value);
+    const bnSwapFeeTokenBalance = (0, _bignumber.default)(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 === _swap.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.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (!bridgeFeeAmount) {
+      return [new _TransactionError.TransactionError(_types.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.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if ((0, _xcmParser._isSnowBridgeXcm)(fromChain, toChain)) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED)];
+    }
+    const bnBridgeFeeAmount = (0, _bignumber.default)(bridgeFeeAmount);
+    const bnBridgeAmount = new _bignumber.default(xcmMetadata.sendingValue);
+    const bridgeToChainNativeToken = this.chainService.getNativeTokenInfo(bridgeToToken.originChain);
+    const bridgeSelectedFeeToken = this.chainService.getAssetBySlug(currentFee.selectedFeeToken || currentFee.defaultFeeToken);
+    const bnBridgeDeliveryFee = (0, _bignumber.default)(0); // todo
+
+    const bridgeSender = (0, _utils4._reformatAddressWithChain)(xcmMetadata.sender, this.chainService.getChainInfoByKey(bridgeFromToken.originChain));
+    const bridgeReceiver = (0, _utils4._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, _KoniTypes.ExtrinsicType.TRANSFER_XCM), this.balanceService.getTransferableBalance(bridgeSender, bridgeFromToken.originChain, bridgeSelectedFeeToken.slug, _KoniTypes.ExtrinsicType.TRANSFER_XCM)]);
+
+    // Native token balance has already accounted for ED aka strict mode
+    const bnBridgeFromTokenBalance = new _bignumber.default(bridgeFromTokenBalance.value).plus(bnSwapReceivingAmount);
+    const bnBridgeFeeTokenBalance = new _bignumber.default(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 === _swap.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.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (!bridgeFeeAmount) {
+      return [new _TransactionError.TransactionError(_types.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 ((0, _xcmParser._isSnowBridgeXcm)(fromChain, toChain)) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED)];
+    }
+    const bnBridgeFeeAmount = (0, _bignumber.default)(bridgeFeeAmount);
+    const bnBridgeAmount = new _bignumber.default(bridgeMetadata.sendingValue);
+    const bridgeToChainNativeToken = this.chainService.getNativeTokenInfo(bridgeToToken.originChain);
+    const bridgeSelectedFeeToken = this.chainService.getAssetBySlug(bridgeFee.selectedFeeToken || bridgeFee.defaultFeeToken);
+    const bnBridgeDeliveryFee = (0, _bignumber.default)(0); // todo
+
+    const bridgeSender = (0, _utils4._reformatAddressWithChain)(bridgeMetadata.sender, this.chainService.getChainInfoByKey(bridgeFromToken.originChain));
+    const bridgeReceiver = (0, _utils4._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, _KoniTypes.ExtrinsicType.TRANSFER_XCM), this.balanceService.getTransferableBalance(bridgeSender, bridgeFromToken.originChain, bridgeSelectedFeeToken.slug, _KoniTypes.ExtrinsicType.TRANSFER_XCM)]);
+
+    // Native token balance has already accounted for ED aka strict mode
+    const bnBridgeFromTokenBalance = new _bignumber.default(bridgeFromTokenBalance.value);
+    const bnBridgeFeeTokenBalance = new _bignumber.default(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 !== _types.SwapStepType.SWAP) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (!swapMetadata || !swapMetadata.destinationTokenInfo || !swapMetadata.originTokenInfo || !swapMetadata.sendingValue || !swapMetadata.expectedReceive) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+
+    // Validate quote
+    if (!params.selectedQuote) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (params.selectedQuote.aliveUntil <= +Date.now()) {
+      return [new _TransactionError.TransactionError(_swap.SwapErrorType.QUOTE_TIMEOUT)];
+    }
+    const swapNetworkFee = swapFee.feeComponent.find(fee => fee.feeType === _swap.SwapFeeType.NETWORK_FEE);
+    if (!swapNetworkFee) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    const swapToken = swapMetadata.originTokenInfo;
+    const swapReceivingToken = swapMetadata.destinationTokenInfo;
+    const bnSwapReceivingAmount = (0, _bignumber.default)(swapMetadata.expectedReceive);
+    if (swapToken.slug !== bridgeToToken.slug) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    const bnSwapValue = (0, _bignumber.default)(swapMetadata.sendingValue);
+    const bnSwapFeeAmount = (0, _bignumber.default)(swapNetworkFee.amount);
+    if (bnSwapValue.gt(bnBridgeAmount)) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (bnSwapValue.lte((0, _utils2._getTokenMinAmount)(swapToken))) {
+      const atLeastString = (0, _utils4.formatNumber)((0, _utils2._getTokenMinAmount)(swapToken), (0, _utils2._getAssetDecimals)(swapToken), _utils4.balanceFormatter, {
+        maxNumberFormat: (0, _utils2._getAssetDecimals)(swapToken) || 6
+      });
+      return [new _TransactionError.TransactionError(_swap.SwapErrorType.NOT_MEET_MIN_SWAP, (0, _i18next.t)(`Swap amount too small. Increase to more than ${atLeastString} ${(0, _utils2._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(params.address, swapFeeToken.originChain, swapFeeToken.slug, _KoniTypes.ExtrinsicType.SWAP), this.balanceService.getTransferableBalance(params.address, swapToken.originChain, swapToken.slug, _KoniTypes.ExtrinsicType.SWAP)]);
+    const [swapFeeTokenBalance, swapFromTokenBalance] = await Promise.all([this.balanceService.getTransferableBalance(swapMetadata.sender, swapFeeToken.originChain, swapFeeToken.slug, _KoniTypes.ExtrinsicType.SWAP), this.balanceService.getTransferableBalance(swapMetadata.sender, swapToken.originChain, swapToken.slug, _KoniTypes.ExtrinsicType.SWAP)]);
     const bnSwapFromTokenBalance = (0, _bignumber.default)(swapFromTokenBalance.value).plus(bnBridgeAmount);
     const bnSwapFeeTokenBalance = (0, _bignumber.default)(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 === _swap.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.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (!transitFee) {
+      return [new _TransactionError.TransactionError(_types.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.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if ((0, _xcmParser._isSnowBridgeXcm)(fromTransitChain, toTransitChain)) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED)];
+    }
+    const bnTransitFeeAmount = (0, _bignumber.default)(transitFee);
+    const bnTransitAmount = new _bignumber.default(transitMetadata.sendingValue);
+    const transitToChainNativeToken = this.chainService.getNativeTokenInfo(transitToToken.originChain);
+    const transitSelectedFeeToken = this.chainService.getAssetBySlug(transitTotalFee.selectedFeeToken || transitTotalFee.defaultFeeToken);
+    const bnTransitDeliveryFee = (0, _bignumber.default)(0); // todo
+
+    const transitSender = (0, _utils4._reformatAddressWithChain)(transitMetadata.sender, this.chainService.getChainInfoByKey(transitFromToken.originChain));
+    const transitReceiver = (0, _utils4._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, _KoniTypes.ExtrinsicType.TRANSFER_XCM), this.balanceService.getTransferableBalance(transitSender, transitFromToken.originChain, transitSelectedFeeToken.slug, _KoniTypes.ExtrinsicType.TRANSFER_XCM)]);
+
+    // Native token balance has already accounted for ED aka strict mode
+    const bnTransitFromTokenBalance = new _bignumber.default(transitFromTokenBalance.value).plus(bnSwapReceivingAmount);
+    const bnTransitFeeTokenBalance = new _bignumber.default(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() {