@eulerxyz/euler-v2-sdk 0.2.3-beta → 0.2.5-beta

package/dist/src/services/executionService/executionService.js

@@ -1,21 +1,111 @@
-import { decodeFunctionData, encodeFunctionData, erc20Abi, getAddress, maxUint256, maxUint160, } from "viem";
+import { decodeFunctionData, encodeFunctionData, erc20Abi, getAddress, maxUint160, maxUint256, } from "viem";
 import { resolveBorrowCollateralPositions } from "../../utils/accountPositionClassification.js";
+import { SwapperMode } from "../swapService/swapServiceTypes.js";
+import { adjustForInterest, getSwapInputAmount, } from "../swapService/swapVerification.js";
 import { ethereumVaultConnectorAbi } from "./abis/ethereumVaultConnectorAbi.js";
 import { eVaultAbi } from "./abis/eVaultAbi.js";
 import { permit2PermitAbi } from "./abis/permit2PermitAbi.js";
 import { swapperAbi } from "./abis/swapperAbi.js";
 import { swapVerifierAbi } from "./abis/swapVerifierAbi.js";
+import { executeCowSwapTransactionPlan, } from "./cowExecutor.js";
+import { computeNonceNamespace, COWSWAP_ORDER_DEADLINE_SECONDS, getCowSwapChainConfig, } from "./cowSwapHelpers.js";
 import * as encodeHelpers from "./encode.js";
-import { isEVCBatchOperation } from "./executionServiceTypes.js";
 import { executeTransactionPlan, } from "./execute.js";
+import { assertNoCowSwapPlanItems, isCowSwapPlanItem, isEVCBatchOperation, } from "./executionServiceTypes.js";
 import { deriveStateOverrides, estimateGasForTransactionPlan, simulateTransactionPlan, } from "./simulate.js";
-import { adjustForInterest, getSwapInputAmount, } from "../swapService/swapVerification.js";
-import { SwapperMode } from "../swapService/swapServiceTypes.js";
-const TOKENS_REQUIRING_ZERO_APPROVAL_RESET = {
-    1: [getAddress("0xdAC17F958D2ee523a2206206994597C13D831ec7")],
-};
-function requiresZeroApprovalReset(chainId, token) {
-    return (TOKENS_REQUIRING_ZERO_APPROVAL_RESET[chainId]?.some((resetToken) => resetToken === getAddress(token)) ?? false);
+import { requiresZeroApprovalReset } from "./tokenApprovalReset.js";
+function isCowSwapQuote(quote) {
+    return quote.route?.some((hop) => hop.providerName?.toLowerCase().includes("cow"));
+}
+function assertNonCowSwapQuote(quote, planFunctionName, cowPlanFunctionName) {
+    if (!isCowSwapQuote(quote))
+        return;
+    const suffix = cowPlanFunctionName
+        ? ` Use ${cowPlanFunctionName} instead.`
+        : " Use the appropriate CoW plan function instead.";
+    throw new Error(`ExecutionService.${planFunctionName} does not support CoW swap quotes.${suffix}`);
+}
+function assertCowSwapQuote(quote, planFunctionName) {
+    if (isCowSwapQuote(quote))
+        return;
+    throw new Error(`ExecutionService.${planFunctionName} requires a CoW swap quote.`);
+}
+function parseCowSwapAmount(field, value) {
+    if (typeof value !== "string" || !/^\d+$/.test(value)) {
+        throw new Error(`CoW quote ${field} missing or invalid`);
+    }
+    return BigInt(value);
+}
+function normalizeCowSwapQuoteId(value) {
+    if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) {
+        return value;
+    }
+    if (typeof value === "string" && /^\d+$/.test(value)) {
+        const parsed = Number(value);
+        if (Number.isSafeInteger(parsed))
+            return parsed;
+    }
+    return undefined;
+}
+function parseSlippagePercent(slippage) {
+    if (!Number.isFinite(slippage) || slippage <= 0) {
+        return { slippageUnits: 0n, denominator: 1n };
+    }
+    const slippageString = slippage.toLocaleString("en-US", {
+        useGrouping: false,
+        maximumFractionDigits: 20,
+    });
+    const [whole = "0", fraction = ""] = slippageString.split(".");
+    const scale = 10n ** BigInt(fraction.length);
+    const slippageUnits = BigInt(whole) * scale + BigInt(fraction || "0");
+    return {
+        slippageUnits,
+        denominator: 100n * scale,
+    };
+}
+function reduceBySlippage(amount, slippage = 0) {
+    const { slippageUnits, denominator } = parseSlippagePercent(slippage);
+    if (slippageUnits >= denominator)
+        return 0n;
+    return (amount * (denominator - slippageUnits)) / denominator;
+}
+function increaseBySlippage(amount, slippage = 0) {
+    const { slippageUnits, denominator } = parseSlippagePercent(slippage);
+    return ((amount * (denominator + slippageUnits) + denominator - 1n) / denominator);
+}
+function getCowSwapQuoteOrderAmounts(quote, options = {}) {
+    const providerData = quote.providerData;
+    const quoteSellAmount = parseCowSwapAmount("providerData.sellAmount", providerData?.sellAmount);
+    const buyAmount = parseCowSwapAmount("providerData.buyAmount", providerData?.buyAmount);
+    const feeAmount = parseCowSwapAmount("providerData.feeAmount", providerData?.feeAmount);
+    const quoteId = normalizeCowSwapQuoteId(providerData?.quoteId);
+    if (quoteSellAmount <= 0n || buyAmount <= 0n) {
+        throw new Error("CoW quote order amount must be positive");
+    }
+    const slippage = options.slippage ?? quote.slippage ?? 0;
+    const orderSellAmount = quoteSellAmount + feeAmount;
+    const slippageAdjustedSellAmount = options.slippageTarget === "sellAmount"
+        ? increaseBySlippage(orderSellAmount, slippage)
+        : orderSellAmount;
+    const adjustedSellAmount = options.maxSellAmount !== undefined &&
+        slippageAdjustedSellAmount > options.maxSellAmount
+        ? options.maxSellAmount
+        : slippageAdjustedSellAmount;
+    const adjustedBuyAmount = options.slippageTarget === "buyAmount"
+        ? reduceBySlippage(buyAmount, slippage)
+        : buyAmount;
+    if (adjustedSellAmount <= 0n || adjustedBuyAmount <= 0n) {
+        throw new Error("CoW quote order amount must be positive");
+    }
+    return {
+        sellAmount: adjustedSellAmount,
+        buyAmount: adjustedBuyAmount,
+        feeAmount,
+        quoteId,
+    };
+}
+function getCowSwapValidTo(validTo) {
+    return (validTo ?? Math.floor(Date.now() / 1000) + COWSWAP_ORDER_DEADLINE_SECONDS);
 }
 function isSavingsCollateral(collateral) {
     return collateral?.source === "savings";
@@ -35,7 +125,9 @@ function hasShareConversion(vault) {
     return (typeof vault === "object" &&
         vault !== null &&
         "convertToShares" in vault &&
-        typeof vault.convertToShares === "function");
+        typeof vault.convertToShares === "function" &&
+        "previewWithdraw" in vault &&
+        typeof vault.previewWithdraw === "function");
 }
 function getStateTransition(item) {
     try {
@@ -199,16 +291,57 @@ export class ExecutionService {
     }
     /** Derive storage overrides needed to simulate the plan against the current account state. */
     async deriveStateOverrides(chainId, account, transactionPlan, options) {
+        assertNoCowSwapPlanItems(transactionPlan, "deriveStateOverrides");
         return deriveStateOverrides(this.getSimulationContext(), chainId, account, transactionPlan, options);
     }
     /** Simulate the full transaction plan, including approval resolution and plugin-aware batch execution. */
     async simulateTransactionPlan(chainId, account, transactionPlan, options) {
+        assertNoCowSwapPlanItems(transactionPlan, "simulateTransactionPlan");
         const processedPlan = await this.processPlanPlugins(transactionPlan, account, chainId);
         const owner = this.getAccountOwner(account);
         return simulateTransactionPlan(this.getSimulationContext(), chainId, owner, processedPlan, options);
     }
+    /**
+     * Simulate a {@link TransactionPlanPrepared} envelope. Plugins and approval
+     * resolution have already run via {@link prepareTransactionPlan}, so this
+     * skips the plugin pipeline and uses the envelope's chainId/account context
+     * directly — no re-fetches of plugin-side data on each click.
+     */
+    async simulatePreparedTransactionPlan(prepared, options) {
+        assertNoCowSwapPlanItems(prepared.plan, "simulatePreparedTransactionPlan");
+        const owner = this.getAccountOwner(prepared.account);
+        return simulateTransactionPlan(this.getSimulationContext(), prepared.chainId, owner, prepared.plan, options);
+    }
+    /**
+     * Run plugins and resolve required approvals up front, packaging the result
+     * with its execution context. Simulate and execute can be called against the
+     * returned envelope repeatedly without re-running plugins or refetching
+     * wallet allowances.
+     */
+    async prepareTransactionPlan(args) {
+        const { plan, chainId, account, usePermit2 = true, unlimitedApproval = false, } = args;
+        assertNoCowSwapPlanItems(plan, "prepareTransactionPlan");
+        const processedPlan = await this.processPlanPlugins(plan, account, chainId);
+        const owner = this.getAccountOwner(account);
+        const resolvedPlan = await this.resolveRequiredApprovals({
+            plan: processedPlan,
+            chainId,
+            account: owner,
+            usePermit2,
+            unlimitedApproval,
+        });
+        return {
+            __prepared: true,
+            plan: resolvedPlan,
+            chainId,
+            account,
+            usePermit2,
+            unlimitedApproval,
+        };
+    }
     /** Estimate gas for the full transaction plan after applying the same simulation pipeline used for execution. */
     async estimateGasForTransactionPlan(chainId, account, transactionPlan, options) {
+        assertNoCowSwapPlanItems(transactionPlan, "estimateGasForTransactionPlan");
         const processedPlan = await this.processPlanPlugins(transactionPlan, account, chainId);
         const owner = this.getAccountOwner(account);
         return estimateGasForTransactionPlan(this.getSimulationContext(), chainId, owner, processedPlan, options);
@@ -219,15 +352,58 @@ export class ExecutionService {
         if (!providerService) {
             throw new Error("ExecutionService.executeTransactionPlan requires a providerService. Pass it to the ExecutionService constructor or call setProviderService().");
         }
+        assertNoCowSwapPlanItems(args.plan, "executeTransactionPlan");
+        const processedPlan = await this.processPlanPlugins(args.plan, args.account, args.chainId);
+        assertNoCowSwapPlanItems(processedPlan, "executeTransactionPlan");
         const helperArgs = {
             ...args,
-            plan: await this.processPlanPlugins(args.plan, args.account, args.chainId),
+            plan: processedPlan,
             executionService: this,
             deploymentService: this.deploymentService,
             providerService,
         };
         return executeTransactionPlan(helperArgs);
     }
+    /**
+     * Execute a {@link TransactionPlanPrepared} envelope. Plugins and approval
+     * resolution were already applied by {@link prepareTransactionPlan}, so
+     * this skips both — no per-execute plugin re-runs or wallet re-fetch.
+     */
+    async executePreparedTransactionPlan(args) {
+        const { providerService } = this;
+        if (!providerService) {
+            throw new Error("ExecutionService.executePreparedTransactionPlan requires a providerService. Pass it to the ExecutionService constructor or call setProviderService().");
+        }
+        const { prepared, sendTransaction, signTypedData, onProgress } = args;
+        assertNoCowSwapPlanItems(prepared.plan, "executePreparedTransactionPlan");
+        const helperArgs = {
+            plan: prepared.plan,
+            chainId: prepared.chainId,
+            account: prepared.account,
+            usePermit2: prepared.usePermit2,
+            unlimitedApproval: prepared.unlimitedApproval,
+            sendTransaction,
+            signTypedData,
+            onProgress,
+            alreadyResolved: true,
+            executionService: this,
+            deploymentService: this.deploymentService,
+            providerService,
+        };
+        return executeTransactionPlan(helperArgs);
+    }
+    async executeCowSwapTransactionPlan(args) {
+        const { providerService } = this;
+        if (!providerService) {
+            throw new Error("ExecutionService.executeCowSwapTransactionPlan requires a providerService. Pass it to the ExecutionService constructor or call setProviderService().");
+        }
+        return executeCowSwapTransactionPlan({
+            ...args,
+            plan: await this.processPlanPlugins(args.plan, args.account, args.chainId),
+            deploymentService: this.deploymentService,
+            providerService,
+        });
+    }
     getSimulationContext() {
         return {
             deploymentService: this.deploymentService,
@@ -786,6 +962,9 @@ export class ExecutionService {
                         });
                     }
                 }
+                else if (isCowSwapPlanItem(item)) {
+                    throw new Error("ExecutionService.mergePlans cannot merge CoW swap plan items. Merge these plans manually to preserve CoW order boundaries.");
+                }
                 else {
                     throw new Error("ExecutionService.mergePlans cannot merge contractCall plan items. Merge these plans manually to preserve call boundaries.");
                 }
@@ -882,6 +1061,7 @@ export class ExecutionService {
      */
     resolveRequiredApprovalsWithWallet(args) {
         const { plan, wallet, chainId, usePermit2 = true, unlimitedApproval = false, } = args;
+        assertNoCowSwapPlanItems(plan, "resolveRequiredApprovalsWithWallet");
         const deployment = this.deploymentService.getDeployment(chainId);
         const permit2 = deployment.addresses.coreAddrs.permit2;
         for (const item of plan) {
@@ -988,11 +1168,17 @@ export class ExecutionService {
      */
     async resolveRequiredApprovals(args) {
         const { plan, chainId, account, usePermit2 = true, unlimitedApproval = false, } = args;
+        assertNoCowSwapPlanItems(plan, "resolveRequiredApprovals");
+        // Filter transaction plan for only RequiredApproval items
+        const requiredApprovals = plan.filter((item) => item.type === "requiredApproval");
+        // No approvals in the plan → nothing to resolve, no wallet fetch needed.
+        // Withdraw/redeem flows always hit this path (they don't transfer assets in).
+        if (requiredApprovals.length === 0) {
+            return plan;
+        }
         if (!this.walletService) {
             throw new Error("ExecutionService.resolveRequiredApprovals requires a walletService. Pass it to the ExecutionService constructor or call setWalletService().");
         }
-        // Filter transaction plan for only RequiredApproval items
-        const requiredApprovals = plan.filter((item) => item.type === "requiredApproval");
         // Transform RequiredApprovals into AssetWithSpenders
         const assetSpendersMap = new Map();
         for (const approval of requiredApprovals) {
@@ -1196,7 +1382,7 @@ export class ExecutionService {
      * @returns Array of transaction plan items (EVC batch; no approvals needed for redeem)
      */
     planRedeem(args) {
-        const { vault, receiver, owner, account, disableCollateral = false, } = args;
+        const { vault, receiver, owner, account, disableCollateral = false } = args;
         const plan = [];
         // Get position to check collateral state
         const position = account?.getPosition(owner, vault);
@@ -1218,13 +1404,14 @@ export class ExecutionService {
             return args.shares;
         const vault = position?.vault;
         if (!hasShareConversion(vault)) {
-            throw new Error("planRedeem with assets requires account position vault state with convertToShares. Populate the account vaults before planning asset-denominated redeem.");
+            throw new Error("planRedeem with assets requires account position vault state with previewWithdraw. Populate the account vaults before planning asset-denominated redeem.");
         }
-        // Asset-denominated redeem intentionally rounds shares down via
-        // convertToShares. Calling withdraw(assets) rounds shares up, which can
-        // burn rounding remainders. The populated vault conversion keeps EVault
-        // virtual deposits in the share calculation.
-        return vault.convertToShares(args.assets);
+        // Asset-denominated redeem must round shares UP so the user receives at
+        // least the requested assets. `convertToShares` rounds down, leaving a
+        // rounding dust shortfall. `previewWithdraw` mirrors the on-chain
+        // previewWithdraw(uint256) — Math.mulDiv with Rounding.Ceil over the
+        // virtual-deposit-adjusted total{Shares,Assets}.
+        return vault.previewWithdraw(args.assets);
     }
     /**
      * Builds a transaction plan for borrowing from a liability vault.
@@ -1497,6 +1684,7 @@ export class ExecutionService {
      */
     planRepayWithSwap(args) {
         const { swapQuote, account, cleanupOnMax = false, swapperMode } = args;
+        assertNonCowSwapQuote(swapQuote, "planRepayWithSwap", "planClosePositionWithCow");
         const plan = [];
         const liabilityPosition = account?.getPosition(swapQuote.accountOut, swapQuote.receiver);
         const fromPosition = account?.getPosition(swapQuote.accountIn, swapQuote.vaultIn);
@@ -1529,6 +1717,74 @@ export class ExecutionService {
         plan.push(...this.convertBatchItemsToPlan(batchItems, "repayWithSwap"));
         return plan;
     }
+    planClosePositionWithCow(args) {
+        const { account, swapQuote, swapperMode = SwapperMode.TARGET_DEBT, slippage, validTo, orderKind, maxSellAmount, } = args;
+        assertCowSwapQuote(swapQuote, "planClosePositionWithCow");
+        const isTargetDebt = swapperMode === SwapperMode.TARGET_DEBT;
+        const sourcePosition = account.getPosition(swapQuote.accountIn, swapQuote.vaultIn);
+        const resolvedMaxSellAmount = maxSellAmount ?? (isTargetDebt ? sourcePosition?.shares : undefined);
+        const orderAmounts = getCowSwapQuoteOrderAmounts(swapQuote, {
+            slippage,
+            slippageTarget: "sellAmount",
+            maxSellAmount: resolvedMaxSellAmount,
+        });
+        const resolvedValidTo = getCowSwapValidTo(validTo);
+        const params = {
+            chainId: account.chainId,
+            sellToken: swapQuote.vaultIn,
+            buyToken: swapQuote.tokenOut.address,
+            sellAmount: orderAmounts.sellAmount,
+            buyAmount: orderAmounts.buyAmount,
+            feeAmount: orderAmounts.feeAmount,
+            quoteId: orderAmounts.quoteId,
+            slippageBips: Math.round((slippage ?? swapQuote.slippage) * 100),
+            validTo: resolvedValidTo,
+            orderKind: orderKind ?? (isTargetDebt ? "buy" : "sell"),
+            wrapper: {
+                owner: account.owner,
+                account: swapQuote.accountOut,
+                deadline: resolvedValidTo,
+                borrowVault: swapQuote.receiver,
+                collateralVault: swapQuote.vaultIn,
+                collateralAmount: orderAmounts.sellAmount,
+            },
+        };
+        return [
+            {
+                type: "cowSwap",
+                kind: "closePosition",
+                chainId: account.chainId,
+                params,
+            },
+        ];
+    }
+    planCancelClosePositionWithCow(args) {
+        const config = getCowSwapChainConfig(args.chainId);
+        if (!config && (!args.wrapperAddress || args.nonceNamespace == null)) {
+            throw new Error(`CoW Swap not supported on chain ${args.chainId}`);
+        }
+        const wrapperAddress = args.wrapperAddress ?? config?.closePositionWrapper;
+        const nonceNamespace = args.nonceNamespace ??
+            (wrapperAddress ? computeNonceNamespace(wrapperAddress) : undefined);
+        if (nonceNamespace == null) {
+            throw new Error("nonceNamespace is required when wrapperAddress is not provided");
+        }
+        const params = {
+            chainId: args.chainId,
+            owner: getAddress(args.owner),
+            nonce: args.nonce,
+            nonceNamespace,
+            wrapperAddress,
+        };
+        return [
+            {
+                type: "cowSwap",
+                kind: "cancelClosePosition",
+                chainId: args.chainId,
+                params,
+            },
+        ];
+    }
     /**
      * Builds a transaction plan for depositing into a vault using tokens from the user's wallet, going through a swap.
      * The approval is given to SwapVerifier (not the vault), then transferFromSender is used in the batch
@@ -1544,6 +1800,7 @@ export class ExecutionService {
      */
     planDepositWithSwapFromWallet(args) {
         const { swapQuote, amount, tokenIn, account, enableCollateral, wrappedNativeInfo, } = args;
+        assertNonCowSwapQuote(swapQuote, "planDepositWithSwapFromWallet");
         const plan = [];
         // Approval goes to the transferFromSender contract (which uses permit2 transferFrom internally)
         plan.push({
@@ -1585,6 +1842,7 @@ export class ExecutionService {
      */
     planSwapFromWallet(args) {
         const { swapQuote, amount, tokenIn, account, wrappedNativeInfo } = args;
+        assertNonCowSwapQuote(swapQuote, "planSwapFromWallet");
         const plan = [];
         plan.push({
             type: "requiredApproval",
@@ -1605,6 +1863,7 @@ export class ExecutionService {
     }
     planSwapAndBorrowFromWallet(args) {
         const { swapQuote, amount, tokenIn, account, borrowVault, borrowAmount, borrowAccount = swapQuote.accountOut, receiver = account.owner, collateralVault = swapQuote.receiver, wrappedNativeInfo, } = args;
+        assertNonCowSwapQuote(swapQuote, "planSwapAndBorrowFromWallet");
         const plan = [];
         plan.push({
             type: "requiredApproval",
@@ -1636,6 +1895,7 @@ export class ExecutionService {
     }
     planSwapAndRepayFromWallet(args) {
         const { swapQuote, amount, tokenIn, account, liabilityVault = swapQuote.receiver, repayAccount = swapQuote.accountOut, isMax, cleanupOnMax = false, wrappedNativeInfo, } = args;
+        assertNonCowSwapQuote(swapQuote, "planSwapAndRepayFromWallet");
         const plan = [];
         plan.push({
             type: "requiredApproval",
@@ -1672,6 +1932,7 @@ export class ExecutionService {
     }
     planWithdrawAndSwap(args) {
         const { account, vault, assets, owner, swapQuote } = args;
+        assertNonCowSwapQuote(args.swapQuote, "planWithdrawAndSwap");
         const batchItems = this.encodeWithdrawAndSwap({
             chainId: account.chainId,
             vault,
@@ -1684,6 +1945,7 @@ export class ExecutionService {
     }
     planRedeemAndSwap(args) {
         const { account, vault, shares, owner, swapQuote } = args;
+        assertNonCowSwapQuote(args.swapQuote, "planRedeemAndSwap");
         const batchItems = this.encodeRedeemAndSwap({
             chainId: account.chainId,
             vault,
@@ -1704,6 +1966,7 @@ export class ExecutionService {
      */
     planSwapCollateral(args) {
         const { swapQuote, account, swapperMode } = args;
+        assertNonCowSwapQuote(swapQuote, "planSwapCollateral", "planSwapCollateralWithCoW");
         const plan = [];
         // Check if source collateral needs to be disabled (when all is swapped)
         // Default: when position is not available, assume amounts are zero, so we don't disable collateral
@@ -1727,6 +1990,47 @@ export class ExecutionService {
         plan.push(...this.convertBatchItemsToPlan(batchItems, "swapCollateral"));
         return plan;
     }
+    planSwapCollateralWithCoW(args) {
+        const { swapQuote, account, slippage, validTo, disableSourceCollateral } = args;
+        assertCowSwapQuote(swapQuote, "planSwapCollateralWithCoW");
+        const orderAmounts = getCowSwapQuoteOrderAmounts(swapQuote, {
+            slippage,
+            slippageTarget: "buyAmount",
+        });
+        const sourcePosition = account.getPosition(swapQuote.accountIn, swapQuote.vaultIn);
+        const resolvedValidTo = getCowSwapValidTo(validTo);
+        const params = {
+            chainId: account.chainId,
+            sellToken: swapQuote.vaultIn,
+            buyToken: swapQuote.receiver,
+            sellAmount: orderAmounts.sellAmount,
+            buyAmount: orderAmounts.buyAmount,
+            feeAmount: orderAmounts.feeAmount,
+            quoteId: orderAmounts.quoteId,
+            slippageBips: Math.round((slippage ?? swapQuote.slippage) * 100),
+            validTo: resolvedValidTo,
+            wrapper: {
+                owner: account.owner,
+                account: swapQuote.accountOut,
+                deadline: resolvedValidTo,
+                fromVault: swapQuote.vaultIn,
+                toVault: swapQuote.receiver,
+                fromAmount: orderAmounts.sellAmount,
+                disableSourceCollateral: disableSourceCollateral ??
+                    (sourcePosition
+                        ? sourcePosition.shares <= orderAmounts.sellAmount
+                        : false),
+            },
+        };
+        return [
+            {
+                type: "cowSwap",
+                kind: "swapCollateral",
+                chainId: account.chainId,
+                params,
+            },
+        ];
+    }
     /**
      * Builds a transaction plan for swapping debt from one liability vault to another (borrow from source → swap → repay to destination).
      *
@@ -1737,6 +2041,7 @@ export class ExecutionService {
      */
     planSwapDebt(args) {
         const { swapQuote, account, swapperMode } = args;
+        assertNonCowSwapQuote(swapQuote, "planSwapDebt");
         const plan = [];
         const liabilityPosition = account?.getPosition(swapQuote.accountIn, swapQuote.receiver);
         const isMax = liabilityPosition
@@ -1925,6 +2230,7 @@ export class ExecutionService {
      */
     planMultiplyWithSwap(args) {
         const { collateralVault, collateralAmount, collateralAsset, collateralShareSource, collateralWrappedNativeInfo, account, swapQuote, swapperMode, } = args;
+        assertNonCowSwapQuote(swapQuote, "planMultiplyWithSwap", "planOpenPositionWithCoW");
         const plan = [];
         // 1. Check if collateral approval is needed (only if depositing collateral)
         if (!collateralShareSource && collateralAmount > 0n) {
@@ -1985,6 +2291,47 @@ export class ExecutionService {
         plan.push(...this.convertBatchItemsToPlan(batchItems, "multiplyWithSwap"));
         return plan;
     }
+    planOpenPositionWithCoW(args) {
+        const { account, collateralVault, collateralAmount, collateralAsset, swapQuote, slippage, validTo, } = args;
+        assertCowSwapQuote(swapQuote, "planOpenPositionWithCoW");
+        if (swapQuote.accountIn !== swapQuote.accountOut) {
+            throw new Error("Account in and account out must be the same");
+        }
+        const orderAmounts = getCowSwapQuoteOrderAmounts(swapQuote, {
+            slippage,
+            slippageTarget: "buyAmount",
+        });
+        const resolvedValidTo = getCowSwapValidTo(validTo);
+        const params = {
+            chainId: account.chainId,
+            sellToken: swapQuote.tokenIn.address,
+            buyToken: swapQuote.receiver,
+            sellAmount: orderAmounts.sellAmount,
+            buyAmount: orderAmounts.buyAmount,
+            feeAmount: orderAmounts.feeAmount,
+            quoteId: orderAmounts.quoteId,
+            slippageBips: Math.round((slippage ?? swapQuote.slippage) * 100),
+            validTo: resolvedValidTo,
+            collateralToken: collateralAsset,
+            wrapper: {
+                owner: account.owner,
+                account: swapQuote.accountIn,
+                deadline: resolvedValidTo,
+                collateralVault,
+                borrowVault: swapQuote.vaultIn,
+                collateralAmount,
+                borrowAmount: orderAmounts.sellAmount,
+            },
+        };
+        return [
+            {
+                type: "cowSwap",
+                kind: "openPosition",
+                chainId: account.chainId,
+                params,
+            },
+        ];
+    }
     /**
      * Builds a transaction plan for a multiply/leverage position when liability and long asset are the same (no swap).
      * Flow: optional collateral deposit → enable controller → borrow to long vault → skim → enable collateral on long vault.