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

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

@@ -6,15 +6,21 @@ Object.defineProperty(exports, "__esModule", {
 });
 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 _utils = require("@subwallet/extension-base/services/chain-service/utils");
-var _utils2 = require("@subwallet/extension-base/services/swap-service/utils");
+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 _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 _utils3 = require("@subwallet/extension-base/utils");
+var _utils4 = require("@subwallet/extension-base/utils");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 var _i18next = require("i18next");
+var _utilCrypto = require("@polkadot/util-crypto");
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
@@ -38,7 +44,30 @@ class SwapBaseHandler {
   async generateOptimalProcess(params, genStepFuncList) {
     const result = {
       totalFee: [_serviceBase.MOCK_STEP_FEE],
-      steps: [_serviceBase.DEFAULT_FIRST_STEP]
+      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],
+      steps: [_serviceBase.DEFAULT_FIRST_STEP],
+      path: params.path
     };
     try {
       for (const genStepFunc of genStepFuncList) {
@@ -59,7 +88,7 @@ class SwapBaseHandler {
   async validateXcmStep(params, stepIndex) {
     const bnAmount = new _bignumber.default(params.selectedQuote.fromAmount);
     const swapPair = params.selectedQuote.pair;
-    const alternativeAssetSlug = (0, _utils2.getSwapAlternativeAsset)(swapPair);
+    const alternativeAssetSlug = (0, _utils3.getSwapAlternativeAsset)(swapPair);
     if (!alternativeAssetSlug) {
       return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
     }
@@ -72,22 +101,22 @@ class SwapBaseHandler {
     const xcmFee = new _bignumber.default(xcmFeeComponent.amount || '0');
     let xcmAmount = bnAmount.minus(bnFromAssetBalance);
     let editedXcmFee = new _bignumber.default(0);
-    if ((0, _utils._isNativeToken)(alternativeAsset)) {
+    if ((0, _utils2._isNativeToken)(alternativeAsset)) {
       xcmAmount = xcmAmount.plus(xcmFee);
       editedXcmFee = xcmFee.times(2);
     }
-    if (!bnAlternativeAssetBalance.minus((0, _utils._isNativeToken)(alternativeAsset) ? xcmAmount.plus(xcmFee) : xcmFee).gt(0)) {
-      const maxBn = bnFromAssetBalance.plus(new _bignumber.default(alternativeAssetBalance.value)).minus((0, _utils._isNativeToken)(alternativeAsset) ? editedXcmFee : xcmFee);
-      const maxValue = (0, _utils3.formatNumber)(maxBn.toString(), fromAsset.decimals || 0);
+    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, _utils3.formatNumber)(bnFromAssetBalance.toString(), fromAsset.decimals || 0);
-      const bnMaxXCM = new _bignumber.default(alternativeAssetBalance.value).minus((0, _utils._isNativeToken)(alternativeAsset) ? editedXcmFee : xcmFee);
-      const maxXCMValue = (0, _utils3.formatNumber)(bnMaxXCM.toString(), fromAsset.decimals || 0);
+      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.`))];
       }
@@ -104,6 +133,108 @@ 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 === _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.`))];
+    }
+
+    /**
+     * 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);
+
+    // 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
+        }
+      }))];
+    }
+
+    // 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
+            }
+          }))];
+        }
+      }
+    }
+
+    // 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([]);
   }
@@ -162,6 +293,189 @@ class SwapBaseHandler {
     }
     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);
+    if (spendingAndFeePaymentValidation.length > 0) {
+      return spendingAndFeePaymentValidation;
+    }
+    if (bnBridgeAmount.lte(minBridgeAmountRequired.plus(bnBridgeDeliveryFee))) {
+      const atLeastStr = (0, _utils4.formatNumber)(minBridgeAmountRequired.plus(bnBridgeDeliveryFee), (0, _utils2._getAssetDecimals)(toToken), _utils4.balanceFormatter, {
+        maxNumberFormat: (0, _utils2._getAssetDecimals)(toToken) || 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: 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.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);
+    if (!isToTokenSufficient && !(0, _utils2._isNativeToken)(toToken)) {
+      // sending token cannot keep account alive, must check with native token
+      const toChainNativeTokenBalance = await this.balanceService.getTotalBalance(receiver, toToken.originChain, toChainNativeToken.slug, _KoniTypes.ExtrinsicType.TRANSFER_BALANCE);
+      if (!(0, _systemPallet._isAccountActive)(toChainNativeTokenBalance.metadata)) {
+        return [new _TransactionError.TransactionError(_types.TransferTxErrorType.RECEIVER_NOT_ENOUGH_EXISTENTIAL_DEPOSIT, (0, _i18next.t)('The recipient account has less than {{amount}} {{nativeSymbol}}, which can lead to your {{localSymbol}} being lost. Change recipient account and try again', {
+          replace: {
+            amount: toChainNativeTokenBalance.value,
+            nativeSymbol: toChainNativeToken.symbol,
+            localSymbol: toToken.symbol
+          }
+        }))];
+      }
+    }
+    return [];
+  }
+  validateSwapStepV2(swapToChain, swapToken, receivingToken, swapFeeToken, bnSwapValue, bnExpectedReceivingAmount, bnSwapFromTokenBalance, bnSwapFeeAmount, bnSwapFeeTokenBalance, recipient) {
+    const spendingAndFeePaymentValidation = (0, _logicValidation.validateSpendingAndFeePayment)(swapToken, swapFeeToken, bnSwapValue, bnSwapFromTokenBalance, bnSwapFeeAmount, bnSwapFeeTokenBalance);
+    if (spendingAndFeePaymentValidation.length > 0) {
+      return spendingAndFeePaymentValidation;
+    }
+    if (bnExpectedReceivingAmount.lte((0, _utils2._getTokenMinAmount)(receivingToken))) {
+      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}}', {
+        replace: {
+          number: atLeastStr,
+          symbol: (0, _utils2._getAssetSymbol)(receivingToken)
+        }
+      }))];
+    }
+    if (recipient) {
+      const isEvmAddress = (0, _utilCrypto.isEthereumAddress)(recipient);
+      const isEvmDestChain = (0, _utils2._isChainEvmCompatible)(swapToChain);
+      if (isEvmAddress && !isEvmDestChain || !isEvmAddress && isEvmDestChain) {
+        // todo: update this condition
+        return [new _TransactionError.TransactionError(_swap2.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.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(_swap2.SwapErrorType.QUOTE_TIMEOUT)];
+    }
+    const swapNetworkFee = swapFee.feeComponent.find(fee => fee.feeType === _swap2.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 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 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);
+  }
+  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 === _swap2.SwapFeeType.NETWORK_FEE)) === null || _currentFee$feeCompon2 === void 0 ? void 0 : _currentFee$feeCompon2.amount;
+    if (!xcmMetadata || !xcmMetadata.destinationTokenInfo || !xcmMetadata.originTokenInfo || !xcmMetadata.sendingValue) {
+      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 ((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)(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 [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 (!swapMetadata || !swapMetadata.destinationTokenInfo || !swapMetadata.originTokenInfo || !swapMetadata.sendingValue) {
+      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(_swap2.SwapErrorType.QUOTE_TIMEOUT)];
+    }
+    const swapNetworkFee = swapFee.feeComponent.find(fee => fee.feeType === _swap2.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);
+    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(_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`))];
+    }
+    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 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);
+    if (swapStepValidation.length > 0) {
+      return swapStepValidation;
+    }
+    return [];
+  }
   get name() {
     return this.providerName;
   }

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

@@ -12,10 +12,9 @@ var _smartContract = require("@subwallet/extension-base/services/balance-service
 var _token = require("@subwallet/extension-base/services/balance-service/transfer/token");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
 var _baseHandler = require("@subwallet/extension-base/services/swap-service/handler/base-handler");
+var _interface = require("@subwallet/extension-base/services/swap-service/interface");
 var _utils2 = 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 _swap = require("@subwallet/extension-base/types/swap");
 var _utils3 = require("@subwallet/extension-base/utils");
 var _getId = require("@subwallet/extension-base/utils/getId");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
@@ -34,10 +33,10 @@ class ChainflipSwapHandler {
       balanceService,
       feeService,
       providerName: isTestnet ? 'Chainflip Testnet' : 'Chainflip',
-      providerSlug: isTestnet ? _swap.SwapProviderId.CHAIN_FLIP_TESTNET : _swap.SwapProviderId.CHAIN_FLIP_MAINNET
+      providerSlug: isTestnet ? _types.SwapProviderId.CHAIN_FLIP_TESTNET : _types.SwapProviderId.CHAIN_FLIP_MAINNET
     });
     this.isTestnet = isTestnet;
-    this.providerSlug = isTestnet ? _swap.SwapProviderId.CHAIN_FLIP_TESTNET : _swap.SwapProviderId.CHAIN_FLIP_MAINNET;
+    this.providerSlug = isTestnet ? _types.SwapProviderId.CHAIN_FLIP_TESTNET : _types.SwapProviderId.CHAIN_FLIP_MAINNET;
     this.baseUrl = (0, _utils2.getChainflipSwap)(isTestnet);
   }
   get chainService() {
@@ -72,9 +71,9 @@ class ChainflipSwapHandler {
     for (const [index, step] of params.process.steps.entries()) {
       const getErrors = async () => {
         switch (step.type) {
-          case _serviceBase.CommonStepType.DEFAULT:
+          case _types.CommonStepType.DEFAULT:
             return Promise.resolve([]);
-          case _serviceBase.CommonStepType.TOKEN_APPROVAL:
+          case _types.CommonStepType.TOKEN_APPROVAL:
             return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
           default:
             return this.swapBaseHandler.validateSwapStep(params, isXcmOk, index);
@@ -83,7 +82,7 @@ class ChainflipSwapHandler {
       const errors = await getErrors();
       if (errors.length) {
         return errors;
-      } else if (step.type === _serviceBase.CommonStepType.XCM) {
+      } else if (step.type === _types.CommonStepType.XCM) {
         isXcmOk = true;
       }
     }
@@ -106,9 +105,19 @@ class ChainflipSwapHandler {
     const fromAssetId = (0, _utils._getAssetSymbol)(fromAsset);
     const toAssetId = (0, _utils._getAssetSymbol)(toAsset);
     const minReceive = new _bignumber.default(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,
@@ -122,6 +131,9 @@ 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,26 +206,78 @@ class ChainflipSwapHandler {
     } = params;
     const type = process.steps[currentStep].type;
     switch (type) {
-      case _serviceBase.CommonStepType.DEFAULT:
+      case _types.CommonStepType.DEFAULT:
         return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
-      case _swap.SwapStepType.SWAP:
+      case _types.SwapStepType.SWAP:
         return this.handleSubmitStep(params);
       default:
         return this.handleSubmitStep(params);
     }
   }
   async getSubmitStep(params) {
-    if (params.selectedQuote) {
-      const submitStep = {
-        name: 'Swap',
-        type: _swap.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: _types.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 ((0, _bignumber.default)(selectedQuote.fromAmount).lte(0)) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
+    }
+    const actionList = JSON.stringify(process.path.map(step => step.action));
+    const swap = actionList === JSON.stringify([_interface.DynamicSwapType.SWAP]);
+    const swapXcm = actionList === JSON.stringify([_interface.DynamicSwapType.SWAP, _interface.DynamicSwapType.BRIDGE]);
+    const xcmSwap = actionList === JSON.stringify([_interface.DynamicSwapType.BRIDGE, _interface.DynamicSwapType.SWAP]);
+    const xcmSwapXcm = actionList === JSON.stringify([_interface.DynamicSwapType.BRIDGE, _interface.DynamicSwapType.SWAP, _interface.DynamicSwapType.BRIDGE]);
+    const swapIndex = params.process.steps.findIndex(step => step.type === _types.SwapStepType.SWAP); // todo
+
+    if (swapIndex <= -1) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (swap) {
+      return this.swapBaseHandler.validateSwapOnlyProcess(params, swapIndex); // todo: create interface for input request
+    }
+
+    if (swapXcm) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwap) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (xcmSwapXcm) {
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
+  }
 }
 exports.ChainflipSwapHandler = ChainflipSwapHandler;