@subwallet/extension-base 1.3.25-0 → 1.3.27-0

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

@@ -2,15 +2,21 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { 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 { _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
-import { getSwapAlternativeAsset } from '@subwallet/extension-base/services/swap-service/utils';
-import { BasicTxErrorType } from '@subwallet/extension-base/types';
+import { _isAccountActive } from '@subwallet/extension-base/core/substrate/system-pallet';
+import { _isSnowBridgeXcm } 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 { formatNumber } from '@subwallet/extension-base/utils';
-import BigNumber from 'bignumber.js';
+import { _reformatAddressWithChain, balanceFormatter, formatNumber } from '@subwallet/extension-base/utils';
+import BigN from 'bignumber.js';
 import { t } from 'i18next';
+import { isEthereumAddress } from '@polkadot/util-crypto';
 export class SwapBaseHandler {
   constructor({
     balanceService,
@@ -30,7 +36,30 @@ export class SwapBaseHandler {
   async generateOptimalProcess(params, genStepFuncList) {
     const result = {
       totalFee: [MOCK_STEP_FEE],
-      steps: [DEFAULT_FIRST_STEP]
+      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],
+      steps: [DEFAULT_FIRST_STEP],
+      path: params.path
     };
     try {
       for (const genStepFunc of genStepFuncList) {
@@ -49,7 +78,7 @@ export class SwapBaseHandler {
     }
   }
   async validateXcmStep(params, stepIndex) {
-    const bnAmount = new BigNumber(params.selectedQuote.fromAmount);
+    const bnAmount = new BigN(params.selectedQuote.fromAmount);
     const swapPair = params.selectedQuote.pair;
     const alternativeAssetSlug = getSwapAlternativeAsset(swapPair);
     if (!alternativeAssetSlug) {
@@ -58,18 +87,18 @@ export class SwapBaseHandler {
     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(alternativeAssetBalance.value);
-    const bnFromAssetBalance = new BigNumber(fromAssetBalance.value);
+    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 BigNumber(xcmFeeComponent.amount || '0');
+    const xcmFee = new BigN(xcmFeeComponent.amount || '0');
     let xcmAmount = bnAmount.minus(bnFromAssetBalance);
-    let editedXcmFee = new BigNumber(0);
+    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 BigNumber(alternativeAssetBalance.value)).minus(_isNativeToken(alternativeAsset) ? editedXcmFee : xcmFee);
+      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;
@@ -78,7 +107,7 @@ export class SwapBaseHandler {
       const inputNetworkName = chain.name;
       const altNetworkName = alternativeChain.name;
       const currentValue = formatNumber(bnFromAssetBalance.toString(), fromAsset.decimals || 0);
-      const bnMaxXCM = new BigNumber(alternativeAssetBalance.value).minus(_isNativeToken(alternativeAsset) ? editedXcmFee : xcmFee);
+      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.`))];
@@ -96,6 +125,108 @@ export class SwapBaseHandler {
     }
     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);
+
+    /**
+     * 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);
+
+    // 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
+        }
+      }))];
+    }
+
+    // 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
+            }
+          }))];
+        }
+      }
+    }
+
+    // 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([]);
   }
@@ -107,8 +238,8 @@ export class SwapBaseHandler {
     const feeAmount = feeInfo.feeComponent[0];
     const feeTokenInfo = this.chainService.getAssetBySlug(feeInfo.defaultFeeToken);
     const feeTokenBalance = await this.balanceService.getTransferableBalance(params.address, feeTokenInfo.originChain, feeTokenInfo.slug);
-    const bnFeeTokenBalance = new BigNumber(feeTokenBalance.value);
-    const bnFeeAmount = new BigNumber(feeAmount.amount);
+    const bnFeeTokenBalance = new BigN(feeTokenBalance.value);
+    const bnFeeAmount = new BigN(feeAmount.amount);
     if (bnFeeAmount.gte(bnFeeTokenBalance)) {
       return Promise.resolve([new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE)]);
     }
@@ -154,6 +285,189 @@ export class SwapBaseHandler {
     }
     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);
+    if (spendingAndFeePaymentValidation.length > 0) {
+      return spendingAndFeePaymentValidation;
+    }
+    if (bnBridgeAmount.lte(minBridgeAmountRequired.plus(bnBridgeDeliveryFee))) {
+      const atLeastStr = formatNumber(minBridgeAmountRequired.plus(bnBridgeDeliveryFee), _getAssetDecimals(toToken), balanceFormatter, {
+        maxNumberFormat: _getAssetDecimals(toToken) || 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: fromToken.symbol
+        }
+      }))];
+    }
+
+    // By here, we know that the user is receiving a valid amount of toToken
+    const toChainApi = this.chainService.getSubstrateApi(toToken.originChain);
+    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);
+    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);
+      if (!_isAccountActive(toChainNativeTokenBalance.metadata)) {
+        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: toChainNativeTokenBalance.value,
+            nativeSymbol: toChainNativeToken.symbol,
+            localSymbol: toToken.symbol
+          }
+        }))];
+      }
+    }
+    return [];
+  }
+  validateSwapStepV2(swapToChain, swapToken, receivingToken, swapFeeToken, bnSwapValue, bnExpectedReceivingAmount, bnSwapFromTokenBalance, bnSwapFeeAmount, bnSwapFeeTokenBalance, recipient) {
+    const spendingAndFeePaymentValidation = validateSpendingAndFeePayment(swapToken, swapFeeToken, bnSwapValue, bnSwapFromTokenBalance, bnSwapFeeAmount, bnSwapFeeTokenBalance);
+    if (spendingAndFeePaymentValidation.length > 0) {
+      return spendingAndFeePaymentValidation;
+    }
+    if (bnExpectedReceivingAmount.lte(_getTokenMinAmount(receivingToken))) {
+      const atLeastStr = formatNumber(_getTokenMinAmount(receivingToken), _getAssetDecimals(receivingToken), balanceFormatter, {
+        maxNumberFormat: _getAssetDecimals(receivingToken) || 6
+      });
+      return [new TransactionError(SwapErrorType.NOT_MEET_MIN_SWAP, t('You can\'t receive less than {{number}} {{symbol}}', {
+        replace: {
+          number: atLeastStr,
+          symbol: _getAssetSymbol(receivingToken)
+        }
+      }))];
+    }
+    if (recipient) {
+      const isEvmAddress = isEthereumAddress(recipient);
+      const isEvmDestChain = _isChainEvmCompatible(swapToChain);
+      if (isEvmAddress && !isEvmDestChain || !isEvmAddress && isEvmDestChain) {
+        // todo: update this condition
+        return [new TransactionError(SwapErrorType.INVALID_RECIPIENT)];
+      }
+    }
+    return [];
+  }
+  async validateSwapOnlyProcess(params, swapIndex) {
+    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) {
+      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(params.selectedQuote.toAmount);
+    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 bnSwapFromTokenBalance = BigN(swapFromTokenBalance.value);
+    const bnSwapFeeTokenBalance = BigN(swapFeeTokenBalance.value);
+    return this.validateSwapStepV2(swapToChain, swapToken, swapReceivingToken, swapFeeToken, bnSwapValue, bnSwapReceivingAmount, bnSwapFromTokenBalance, bnSwapFeeAmount, bnSwapFeeTokenBalance, params.recipient);
+  }
+  async validateXcmSwapProcess(params, swapIndex, xcmIndex) {
+    var _currentFee$feeCompon2, _params$recipient2;
+    // 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) {
+      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 (_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(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 [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 (!swapMetadata || !swapMetadata.destinationTokenInfo || !swapMetadata.originTokenInfo || !swapMetadata.sendingValue) {
+      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(params.selectedQuote.toAmount);
+    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(params.address, swapFeeToken.originChain, swapFeeToken.slug, ExtrinsicType.SWAP), this.balanceService.getTransferableBalance(params.address, 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);
+    if (swapStepValidation.length > 0) {
+      return swapStepValidation;
+    }
+    return [];
+  }
   get name() {
     return this.providerName;
   }

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

@@ -4,8 +4,7 @@ import { BalanceService } from '@subwallet/extension-base/services/balance-servi
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
 import FeeService from '@subwallet/extension-base/services/fee-service/service';
 import { SwapBaseInterface } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
-import { BaseStepDetail, CommonOptimalPath, CommonStepFeeInfo } from '@subwallet/extension-base/types/service-base';
-import { OptimalSwapPathParams, SwapProviderId, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
+import { BaseStepDetail, CommonOptimalSwapPath, CommonStepFeeInfo, OptimalSwapPathParams, OptimalSwapPathParamsV2, SwapProviderId, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types';
 export declare const CHAINFLIP_BROKER_API: string;
 export declare class ChainflipSwapHandler implements SwapBaseInterface {
     private readonly isTestnet;
@@ -23,5 +22,7 @@ export declare class ChainflipSwapHandler implements SwapBaseInterface {
     handleSubmitStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     handleSwapProcess(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     getSubmitStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
-    generateOptimalProcess(params: OptimalSwapPathParams): Promise<CommonOptimalPath>;
+    generateOptimalProcess(params: OptimalSwapPathParams): Promise<CommonOptimalSwapPath>;
+    generateOptimalProcessV2(params: OptimalSwapPathParamsV2): Promise<CommonOptimalSwapPath>;
+    validateSwapProcessV2(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
 }

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

@@ -8,10 +8,9 @@ import { getERC20TransactionObject, getEVMTransactionObject } from '@subwallet/e
 import { createSubstrateExtrinsic } from '@subwallet/extension-base/services/balance-service/transfer/token';
 import { _getAssetSymbol, _getContractAddressOfToken, _isChainSubstrateCompatible, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
 import { SwapBaseHandler } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
+import { DynamicSwapType } from '@subwallet/extension-base/services/swap-service/interface';
 import { getChainflipSwap } from '@subwallet/extension-base/services/swap-service/utils';
-import { BasicTxErrorType } from '@subwallet/extension-base/types';
-import { CommonStepType } from '@subwallet/extension-base/types/service-base';
-import { SwapProviderId, SwapStepType } from '@subwallet/extension-base/types/swap';
+import { BasicTxErrorType, CommonStepType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types';
 import { _reformatAddressWithChain } from '@subwallet/extension-base/utils';
 import { getId } from '@subwallet/extension-base/utils/getId';
 import BigNumber from 'bignumber.js';
@@ -97,9 +96,19 @@ export class ChainflipSwapHandler {
     const fromAssetId = _getAssetSymbol(fromAsset);
     const toAssetId = _getAssetSymbol(toAsset);
     const minReceive = new BigNumber(quote.rate).times(1 - slippage).toString();
+    const processMetadata = params.process.steps[params.currentStep].metadata;
+    const quoteMetadata = params.quote.metadata;
+    if (!processMetadata || !quoteMetadata) {
+      throw new Error('Metadata for Chainflip not found');
+    }
+    if (processMetadata.destChain !== quoteMetadata.destChain || processMetadata.srcChain !== quoteMetadata.srcChain) {
+      throw new Error('Metadata for Chainflip not found');
+    }
     const depositParams = {
+      sourceChain: processMetadata.srcChain,
       destinationAddress: receiver,
       destinationAsset: toAssetId,
+      destinationChain: processMetadata.destChain,
       minimumPrice: minReceive,
       // minimum accepted price for swaps through the channel
       refundAddress: address,
@@ -113,6 +122,9 @@ export class ChainflipSwapHandler {
       method: 'GET'
     });
     const data = await response.json();
+    if (!data.id || !data.address || data.address === '' || !data.issuedBlock || !data.network || !data.channelId) {
+      throw new Error('Error get Chainflip data');
+    }
     const depositChannelId = `${data.issuedBlock}-${data.network}-${data.channelId}`;
     const depositAddress = data.address;
     const txData = {
@@ -194,16 +206,68 @@ export class ChainflipSwapHandler {
     }
   }
   async getSubmitStep(params) {
-    if (params.selectedQuote) {
-      const submitStep = {
-        name: 'Swap',
-        type: SwapStepType.SWAP
-      };
-      return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
+    var _params$selectedQuote;
+    const metadata = (_params$selectedQuote = params.selectedQuote) === null || _params$selectedQuote === void 0 ? void 0 : _params$selectedQuote.metadata;
+    if (!params.selectedQuote) {
+      return Promise.resolve(undefined);
+    }
+    if (!metadata || !metadata.srcChain || !metadata.destChain) {
+      return Promise.resolve(undefined);
     }
-    return Promise.resolve(undefined);
+    const submitStep = {
+      name: 'Swap',
+      type: SwapStepType.SWAP,
+      metadata: {
+        sendingValue: params.request.fromAmount.toString(),
+        originTokenInfo: this.chainService.getAssetBySlug(params.selectedQuote.pair.from),
+        destinationTokenInfo: this.chainService.getAssetBySlug(params.selectedQuote.pair.to),
+        srcChain: metadata.srcChain,
+        destChain: metadata.destChain
+      }
+    };
+    return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
   }
   generateOptimalProcess(params) {
     return this.swapBaseHandler.generateOptimalProcess(params, [this.getSubmitStep.bind(this)]);
   }
+  generateOptimalProcessV2(params) {
+    return this.swapBaseHandler.generateOptimalProcessV2(params, [this.getSubmitStep.bind(this)]);
+  }
+  async validateSwapProcessV2(params) {
+    // todo: recheck address and recipient format in params
+    const {
+      process,
+      selectedQuote
+    } = params; // todo: review flow, currentStep param.
+
+    // todo: validate path with optimalProcess
+    // todo: review error message in case many step swap
+    if (BigNumber(selectedQuote.fromAmount).lte(0)) {
+      return [new TransactionError(BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
+    }
+    const actionList = JSON.stringify(process.path.map(step => step.action));
+    const swap = actionList === JSON.stringify([DynamicSwapType.SWAP]);
+    const swapXcm = actionList === JSON.stringify([DynamicSwapType.SWAP, DynamicSwapType.BRIDGE]);
+    const xcmSwap = actionList === JSON.stringify([DynamicSwapType.BRIDGE, DynamicSwapType.SWAP]);
+    const xcmSwapXcm = actionList === JSON.stringify([DynamicSwapType.BRIDGE, DynamicSwapType.SWAP, DynamicSwapType.BRIDGE]);
+    const swapIndex = params.process.steps.findIndex(step => step.type === SwapStepType.SWAP); // todo
+
+    if (swapIndex <= -1) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (swap) {
+      return this.swapBaseHandler.validateSwapOnlyProcess(params, swapIndex); // todo: create interface for input request
+    }
+
+    if (swapXcm) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwap) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwapXcm) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+  }
 }

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

@@ -3,8 +3,9 @@ import { BalanceService } from '@subwallet/extension-base/services/balance-servi
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
 import FeeService from '@subwallet/extension-base/services/fee-service/service';
 import { SwapBaseInterface } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
-import { BaseStepDetail, CommonOptimalPath, CommonStepFeeInfo } from '@subwallet/extension-base/types/service-base';
-import { OptimalSwapPathParams, SwapProviderId, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
+import { OptimalSwapPathParamsV2, ValidateSwapProcessParams } from '@subwallet/extension-base/types';
+import { BaseStepDetail, CommonOptimalSwapPath, CommonStepFeeInfo } from '@subwallet/extension-base/types/service-base';
+import { OptimalSwapPathParams, SwapProviderId, SwapSubmitParams, SwapSubmitStepData } from '@subwallet/extension-base/types/swap';
 export declare class HydradxHandler implements SwapBaseInterface {
     private swapBaseHandler;
     private tradeRouter;
@@ -22,12 +23,16 @@ export declare class HydradxHandler implements SwapBaseInterface {
     getXcmStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
     getFeeOptionStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
     getSubmitStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
-    generateOptimalProcess(params: OptimalSwapPathParams): Promise<CommonOptimalPath>;
+    getXcmStepV2(params: OptimalSwapPathParamsV2): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
+    getSwapStepV2(params: OptimalSwapPathParamsV2): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
+    generateOptimalProcess(params: OptimalSwapPathParams): Promise<CommonOptimalSwapPath>;
+    generateOptimalProcessV2(params: OptimalSwapPathParamsV2): Promise<CommonOptimalSwapPath>;
     handleXcmStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     handleSetFeeStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     handleSubmitStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     handleSwapProcess(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     validateSwapProcess(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
+    validateSwapProcessV2(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
     get referralCode(): "WALLET" | "ASSETHUB";
     get referralAccount(): "7PCsCpkgsHdNaZhv79wCCQ5z97uxVbSeSCtDMUa1eZHKXy4a" | "7LCt6dFqtxzdKVB2648jWW9d85doiFfLSbZJDNAMVJNxh5rJ";
 }