@eulerxyz/euler-v2-sdk 0.1.3-beta → 0.2.1-beta

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

@@ -9,6 +9,8 @@ import * as encodeHelpers from "./encode.js";
 import { isEVCBatchOperation } from "./executionServiceTypes.js";
 import { executeTransactionPlan, } from "./execute.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")],
 };
@@ -26,6 +28,118 @@ function cloneBatchEntries(entries) {
         ? { type: "operation", name: entry.name, items: [...entry.items] }
         : entry);
 }
+function hasSuppliedPosition(position) {
+    return position.assets > 0n || position.shares > 0n;
+}
+function getStateTransition(item) {
+    try {
+        const decoded = decodeFunctionData({
+            abi: ethereumVaultConnectorAbi,
+            data: item.data,
+        });
+        if (decoded.functionName === "enableCollateral" ||
+            decoded.functionName === "disableCollateral" ||
+            decoded.functionName === "enableController") {
+            const [account, vault] = decoded.args;
+            return {
+                kind: decoded.functionName === "enableController"
+                    ? "controller"
+                    : "collateral",
+                action: decoded.functionName.startsWith("enable")
+                    ? "enable"
+                    : "disable",
+                account,
+                vault,
+            };
+        }
+    }
+    catch { }
+    try {
+        const decoded = decodeFunctionData({
+            abi: eVaultAbi,
+            data: item.data,
+        });
+        if (decoded.functionName === "disableController") {
+            return {
+                kind: "controller",
+                action: "disable",
+                account: item.onBehalfOfAccount,
+                vault: item.targetContract,
+            };
+        }
+    }
+    catch { }
+    return undefined;
+}
+function stateTransitionKey(transition) {
+    return `${transition.kind}:${getAddress(transition.account)}:${getAddress(transition.vault)}`;
+}
+function normalizeEVCStateTransitions(entries) {
+    const entryRefs = entries.map((entry) => isEVCBatchOperation(entry)
+        ? entry.items.map((item) => ({
+            item,
+            remove: false,
+            transition: getStateTransition(item),
+        }))
+        : [
+            {
+                item: entry,
+                remove: false,
+                transition: getStateTransition(entry),
+            },
+        ]);
+    const refs = entryRefs.flat();
+    const collateralStacks = new Map();
+    const controllerLast = new Map();
+    for (const ref of refs) {
+        const transition = ref.transition;
+        if (!transition)
+            continue;
+        const key = stateTransitionKey(transition);
+        if (transition.kind === "collateral") {
+            const stack = collateralStacks.get(key) ?? [];
+            const previous = stack[stack.length - 1];
+            if (previous?.action === transition.action) {
+                ref.remove = true;
+            }
+            else if (previous) {
+                previous.ref.remove = true;
+                ref.remove = true;
+                stack.pop();
+            }
+            else {
+                stack.push({ action: transition.action, ref });
+            }
+            collateralStacks.set(key, stack);
+            continue;
+        }
+        const previous = controllerLast.get(key);
+        if (previous?.action === transition.action) {
+            ref.remove = true;
+        }
+        else {
+            controllerLast.set(key, { action: transition.action });
+        }
+    }
+    const result = [];
+    entries.forEach((entry, index) => {
+        const refsForEntry = entryRefs[index] ?? [];
+        if (isEVCBatchOperation(entry)) {
+            const items = refsForEntry
+                .filter((ref) => !ref.remove)
+                .map((ref) => ref.item);
+            if (items.length > 0) {
+                result.push({ type: "operation", name: entry.name, items });
+            }
+            return;
+        }
+        const ref = refsForEntry[0];
+        if (ref && !ref.remove) {
+            result.push(ref.item);
+        }
+    });
+    return result;
+}
 const WAD = 10n ** 18n;
 // TODO explain how this service is coupled to the concrete abis of ERC4626, permit2 and EVK.
 // this is a helper service, not a generic one.
@@ -39,6 +153,7 @@ export class ExecutionService {
     rewardsService;
     intrinsicApyService;
     eulerLabelsService;
+    processPlugins;
     constructor(deploymentService, walletService, providerService, vaultMetaService, priceService, rewardsService, intrinsicApyService, eulerLabelsService) {
         this.deploymentService = deploymentService;
         this.walletService = walletService;
@@ -73,17 +188,24 @@ export class ExecutionService {
     setPlugins(plugins) {
         this.plugins = plugins;
     }
+    setPluginProcessor(processPlugins) {
+        this.processPlugins = processPlugins;
+    }
     /** Derive storage overrides needed to simulate the plan against the current account state. */
     async deriveStateOverrides(chainId, account, transactionPlan, options) {
         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) {
-        return simulateTransactionPlan(this.getSimulationContext(), chainId, account, transactionPlan, options);
+        const processedPlan = await this.processPlanPlugins(transactionPlan, account, chainId);
+        const owner = this.getAccountOwner(account);
+        return simulateTransactionPlan(this.getSimulationContext(), chainId, owner, processedPlan, options);
     }
     /** Estimate gas for the full transaction plan after applying the same simulation pipeline used for execution. */
     async estimateGasForTransactionPlan(chainId, account, transactionPlan, options) {
-        return estimateGasForTransactionPlan(this.getSimulationContext(), chainId, account, transactionPlan, options);
+        const processedPlan = await this.processPlanPlugins(transactionPlan, account, chainId);
+        const owner = this.getAccountOwner(account);
+        return estimateGasForTransactionPlan(this.getSimulationContext(), chainId, owner, processedPlan, options);
     }
     /** Execute a transaction plan using caller-provided signing and send callbacks. */
     async executeTransactionPlan(args) {
@@ -93,6 +215,7 @@ export class ExecutionService {
         }
         const helperArgs = {
             ...args,
+            plan: await this.processPlanPlugins(args.plan, args.account, args.chainId),
             executionService: this,
             deploymentService: this.deploymentService,
             providerService,
@@ -112,6 +235,14 @@ export class ExecutionService {
             describeBatch: (batch) => this.describeBatch(batch),
         };
     }
+    async processPlanPlugins(plan, account, chainId) {
+        return this.processPlugins
+            ? this.processPlugins(plan, account, chainId)
+            : plan;
+    }
+    getAccountOwner(account) {
+        return typeof account === "string" ? account : account.owner;
+    }
     getCoreAddresses(chainId) {
         return this.deploymentService.getDeployment(chainId).addresses.coreAddrs;
     }
@@ -382,6 +513,19 @@ export class ExecutionService {
     encodeSwapFromWallet(args) {
         return encodeHelpers.encodeSwapFromWallet(args);
     }
+    encodeSwapAndBorrowFromWallet(args) {
+        const { evc } = this.getCoreAddresses(args.chainId);
+        return encodeHelpers.encodeSwapAndBorrowFromWallet(evc, args);
+    }
+    encodeSwapAndRepayFromWallet(args) {
+        return encodeHelpers.encodeSwapAndRepayFromWallet(args);
+    }
+    encodeWithdrawAndSwap(args) {
+        return encodeHelpers.encodeWithdrawAndSwap(args);
+    }
+    encodeRedeemAndSwap(args) {
+        return encodeHelpers.encodeRedeemAndSwap(args);
+    }
     /**
      * Encodes EVC batch items for swapping collateral: withdraw from vaultIn → swap → verify/skim to receiver; optional enable/disable collateral.
      * Swap quote should come from swapService.fetchDepositQuote() or match the same structure (verify type skimMin).
@@ -514,7 +658,7 @@ export class ExecutionService {
      * @param args.spender - Address that will be allowed to transfer the token (e.g. vault or Permit2)
      * @param args.nonce - Unique nonce for this permit (e.g. from Permit2 nonce(owner, token, spender))
      * @param args.sigDeadline - Signature deadline (defaults to now + 1 hour if omitted)
-     * @param args.expiration - Permit expiration (defaults to maxUint48 if omitted)
+     * @param args.expiration - Permit expiration (defaults to now + 1 hour if omitted)
      * @returns EIP-712 typed data (domain, types, primaryType, message) for signing
      */
     getPermit2TypedData(args) {
@@ -641,7 +785,13 @@ export class ExecutionService {
                 }
             }
         }
-        return [...approvalByKey.values(), ...executableItems];
+        const optimizedExecutableItems = executableItems.flatMap((item) => {
+            if (item.type !== "evcBatch")
+                return [item];
+            const items = normalizeEVCStateTransitions(item.items);
+            return items.length > 0 ? [{ type: "evcBatch", items }] : [];
+        });
+        return [...approvalByKey.values(), ...optimizedExecutableItems];
     }
     /**
      * Appends a raw batch item to the last EVC batch in the plan, or creates one.
@@ -721,11 +871,11 @@ export class ExecutionService {
      * @param args.chainId - Chain ID (used to resolve Permit2 address when usePermit2 is true)
      * @param args.wallet - Wallet entity with token balances and allowances (assetForVault, assetForPermit2, etc.)
      * @param args.usePermit2 - If true, prefer Permit2 path (approve Permit2 + sign PermitSingle) when allowance is insufficient (default true)
-     * @param args.unlimitedApproval - If true, approval/permit amounts use maxUint256/maxUint160 (default true)
+     * @param args.unlimitedApproval - If true, direct approvals and Permit2 signed amounts use maxUint256/maxUint160 (default false). Token approvals to Permit2 use maxUint256.
      * @returns The same plan array with requiredApproval[].resolved populated (approve and/or permit2 data to sign)
      */
     resolveRequiredApprovalsWithWallet(args) {
-        const { plan, wallet, chainId, usePermit2 = true, unlimitedApproval = true, } = args;
+        const { plan, wallet, chainId, usePermit2 = true, unlimitedApproval = false, } = args;
         const deployment = this.deploymentService.getDeployment(chainId);
         const permit2 = deployment.addresses.coreAddrs.permit2;
         for (const item of plan) {
@@ -766,7 +916,7 @@ export class ExecutionService {
                 if (!walletAsset || !allowances) {
                     if (usePermit2) {
                         // Need approval to permit2 and permit2 signature
-                        resolvedItems.push(makeApprove(permit2, unlimitedApproval ? maxUint256 : amount));
+                        resolvedItems.push(makeApprove(permit2, maxUint256));
                         resolvedItems.push(makePermit2(spender, unlimitedApproval ? maxUint160 : amount));
                     }
                     else {
@@ -793,7 +943,7 @@ export class ExecutionService {
                     }
                     // If assetForPermit2 is insufficient, we need both approval and permit2 signature
                     if (!hasSufficientPermit2Allowance) {
-                        addApproveWithOptionalReset(permit2, unlimitedApproval ? maxUint256 : amount, assetForPermit2);
+                        addApproveWithOptionalReset(permit2, maxUint256, assetForPermit2);
                         resolvedItems.push(makePermit2(spender, unlimitedApproval ? maxUint160 : amount));
                     }
                     else {
@@ -863,6 +1013,55 @@ export class ExecutionService {
         });
     }
     // ========== Transaction plan functions ==========
+    /**
+     * Builds a cleanup plan matching Lite's stale collateral/controller policy.
+     *
+     * Cleanup is derived from the provided account snapshot:
+     * - no enabled controllers: disable all enabled collaterals
+     * - enabled controllers but no active borrows: disable all collaterals, then controllers
+     * - active borrows: disable only enabled collaterals with no supplied position
+     *
+     * If the sub-account snapshot is unavailable, no cleanup is planned.
+     */
+    planCleanup(args) {
+        const { account, subAccount } = args;
+        if (typeof account.getSubAccount !== "function")
+            return [];
+        const subAccountSnapshot = account.getSubAccount(subAccount);
+        if (!subAccountSnapshot)
+            return [];
+        const collaterals = subAccountSnapshot.enabledCollaterals ?? [];
+        const controllers = subAccountSnapshot.enabledControllers ?? [];
+        if (collaterals.length === 0 && controllers.length === 0)
+            return [];
+        const items = [];
+        const disableAllCollaterals = () => {
+            for (const collateral of collaterals) {
+                items.push(this.encodeDisableCollateral(account.chainId, subAccount, collateral));
+            }
+        };
+        if (controllers.length === 0) {
+            disableAllCollaterals();
+            return this.convertBatchItemsToPlan(items, "cleanup");
+        }
+        const hasActiveBorrow = subAccountSnapshot.positions.some((position) => position.borrowed > 0n);
+        if (!hasActiveBorrow) {
+            disableAllCollaterals();
+            for (const controller of controllers) {
+                items.push(this.encodeDisableController(controller, subAccount));
+            }
+            return this.convertBatchItemsToPlan(items, "cleanup");
+        }
+        const depositedVaults = new Set(subAccountSnapshot.positions
+            .filter(hasSuppliedPosition)
+            .map((position) => getAddress(position.vaultAddress)));
+        for (const collateral of collaterals) {
+            if (depositedVaults.has(getAddress(collateral)))
+                continue;
+            items.push(this.encodeDisableCollateral(account.chainId, subAccount, collateral));
+        }
+        return this.convertBatchItemsToPlan(items, "cleanup");
+    }
     /**
      * Builds a transaction plan for depositing assets into a vault.
      * Use `maxUint256` for `amount` to deposit all available assets from the wallet.
@@ -877,7 +1076,7 @@ export class ExecutionService {
      * @returns Array of transaction plan items (required approvals + EVC batch)
      */
     planDeposit(args) {
-        const { vault, amount, receiver, account, asset, enableCollateral } = args;
+        const { vault, amount, receiver, account, asset, enableCollateral, wrappedNativeInfo, } = args;
         const plan = [];
         // Default: collateral is not enabled when account/position is not available
         const isCollateralEnabled = account?.isCollateralEnabled(receiver, vault) ?? false;
@@ -897,6 +1096,7 @@ export class ExecutionService {
             receiver,
             owner: account.owner,
             enableCollateral: !isCollateralEnabled && enableCollateral,
+            wrappedNativeInfo,
             // Permit2 is handled separately in the plan
         });
         plan.push(...this.convertBatchItemsToPlan(batchItems, "deposit"));
@@ -916,7 +1116,7 @@ export class ExecutionService {
      * @returns Array of transaction plan items (required approvals + EVC batch)
      */
     planMint(args) {
-        const { vault, shares, receiver, account, asset, enableCollateral, sharesToAssetsExchangeRateWad, } = args;
+        const { vault, shares, receiver, account, asset, enableCollateral, sharesToAssetsExchangeRateWad, wrappedNativeInfo, } = args;
         const plan = [];
         // Default: collateral is not enabled when account/position is not available
         const isCollateralEnabled = account?.isCollateralEnabled(receiver, vault) ?? false;
@@ -939,6 +1139,7 @@ export class ExecutionService {
             receiver,
             owner: account.owner,
             enableCollateral: !isCollateralEnabled && enableCollateral,
+            wrappedNativeInfo,
             // Permit2 is handled separately in the plan
         });
         plan.push(...this.convertBatchItemsToPlan(batchItems, "mint"));
@@ -1059,6 +1260,7 @@ export class ExecutionService {
             enableCollateral,
             collateralVault: collateral?.vault,
             collateralAmount: walletCollateral?.amount,
+            collateralWrappedNativeInfo: walletCollateral?.wrappedNativeInfo,
             collateralShareSource: savingsCollateral
                 ? {
                     from: savingsCollateral.from,
@@ -1136,15 +1338,16 @@ export class ExecutionService {
         if (!position) {
             throw new Error(`Position not found. Liability vault: ${liabilityVault}, Account: ${receiver}`);
         }
+        const isMax = liabilityAmount === maxUint256;
+        const approvalAmount = adjustForInterest(isMax ? position.borrowed : liabilityAmount);
         // Add approval requirement (will be resolved later with Wallet data)
         plan.push({
             type: "requiredApproval",
             token: position.asset,
             owner: account.owner,
             spender: liabilityVault,
-            amount: liabilityAmount,
+            amount: approvalAmount,
         });
-        const isMax = liabilityAmount === maxUint256;
         // Build EVC batch items
         const batchItems = this.encodeRepayFromWallet({
             chainId: account.chainId,
@@ -1271,7 +1474,7 @@ export class ExecutionService {
      * @returns Array of transaction plan items (EVC batch: withdraw, swap, verify/repay). Throws if positions not found or liability is zero.
      */
     planRepayWithSwap(args) {
-        const { swapQuote, account, cleanupOnMax = false } = args;
+        const { swapQuote, account, cleanupOnMax = false, swapperMode } = args;
         const plan = [];
         const liabilityPosition = account?.getPosition(swapQuote.accountOut, swapQuote.receiver);
         const fromPosition = account?.getPosition(swapQuote.accountIn, swapQuote.vaultIn);
@@ -1289,6 +1492,7 @@ export class ExecutionService {
             maxWithdraw,
             isMax,
             disableControllerOnMax: true,
+            swapperMode,
         });
         if (cleanupOnMax && isMax) {
             this.appendMaxRepayCleanup({
@@ -1317,7 +1521,7 @@ export class ExecutionService {
      * @returns Array of transaction plan items (approval to SwapVerifier + EVC batch)
      */
     planDepositWithSwapFromWallet(args) {
-        const { swapQuote, amount, tokenIn, account, enableCollateral } = args;
+        const { swapQuote, amount, tokenIn, account, enableCollateral, wrappedNativeInfo, } = args;
         const plan = [];
         // Approval goes to the transferFromSender contract (which uses permit2 transferFrom internally)
         plan.push({
@@ -1341,6 +1545,7 @@ export class ExecutionService {
             amount,
             sender: account.owner,
             enableCollateral: shouldEnableCollateral,
+            wrappedNativeInfo,
         });
         plan.push(...this.convertBatchItemsToPlan(batchItems, "depositWithSwapFromWallet"));
         return plan;
@@ -1357,7 +1562,7 @@ export class ExecutionService {
      * @returns Array of transaction plan items (approval to SwapVerifier + EVC batch)
      */
     planSwapFromWallet(args) {
-        const { swapQuote, amount, tokenIn, account } = args;
+        const { swapQuote, amount, tokenIn, account, wrappedNativeInfo } = args;
         const plan = [];
         plan.push({
             type: "requiredApproval",
@@ -1371,10 +1576,102 @@ export class ExecutionService {
             swapQuote,
             amount,
             sender: account.owner,
+            wrappedNativeInfo,
         });
         plan.push(...this.convertBatchItemsToPlan(batchItems, "swapFromWallet"));
         return plan;
     }
+    planSwapAndBorrowFromWallet(args) {
+        const { swapQuote, amount, tokenIn, account, borrowVault, borrowAmount, borrowAccount = swapQuote.accountOut, receiver = account.owner, collateralVault = swapQuote.receiver, wrappedNativeInfo, } = args;
+        const plan = [];
+        plan.push({
+            type: "requiredApproval",
+            token: tokenIn,
+            owner: account.owner,
+            spender: swapQuote.verify.verifierAddress,
+            amount,
+        });
+        const enableController = !(account?.isControllerEnabled(borrowAccount, borrowVault) ?? false);
+        const enableCollateral = !(account?.isCollateralEnabled(borrowAccount, collateralVault) ?? false);
+        const currentController = account?.getCurrentController(borrowAccount);
+        const batchItems = this.encodeSwapAndBorrowFromWallet({
+            chainId: account.chainId,
+            swapQuote,
+            amount,
+            sender: account.owner,
+            borrowAccount,
+            collateralVault,
+            borrowVault,
+            borrowAmount,
+            receiver,
+            currentController: currentController || undefined,
+            enableController,
+            enableCollateral,
+            wrappedNativeInfo,
+        });
+        plan.push(...this.convertBatchItemsToPlan(batchItems, "swapAndBorrowFromWallet"));
+        return plan;
+    }
+    planSwapAndRepayFromWallet(args) {
+        const { swapQuote, amount, tokenIn, account, liabilityVault = swapQuote.receiver, repayAccount = swapQuote.accountOut, isMax, cleanupOnMax = false, wrappedNativeInfo, } = args;
+        const plan = [];
+        plan.push({
+            type: "requiredApproval",
+            token: tokenIn,
+            owner: account.owner,
+            spender: swapQuote.verify.verifierAddress,
+            amount,
+        });
+        const liabilityPosition = account?.getPosition(repayAccount, liabilityVault);
+        const resolvedIsMax = isMax ??
+            (liabilityPosition !== undefined &&
+                liabilityPosition.borrowed <= BigInt(swapQuote.amountOutMin || 0));
+        const batchItems = this.encodeSwapAndRepayFromWallet({
+            chainId: account.chainId,
+            swapQuote,
+            amount,
+            sender: account.owner,
+            liabilityVault,
+            repayAccount,
+            isMax: resolvedIsMax,
+            disableControllerOnMax: true,
+            wrappedNativeInfo,
+        });
+        if (cleanupOnMax && resolvedIsMax && liabilityPosition) {
+            this.appendMaxRepayCleanup({
+                account,
+                liabilityPosition,
+                receiver: repayAccount,
+                batchItems,
+            });
+        }
+        plan.push(...this.convertBatchItemsToPlan(batchItems, "swapAndRepayFromWallet"));
+        return plan;
+    }
+    planWithdrawAndSwap(args) {
+        const { account, vault, assets, owner, swapQuote } = args;
+        const batchItems = this.encodeWithdrawAndSwap({
+            chainId: account.chainId,
+            vault,
+            assets,
+            owner,
+            sender: account.owner,
+            swapQuote,
+        });
+        return this.convertBatchItemsToPlan(batchItems, "withdrawAndSwap");
+    }
+    planRedeemAndSwap(args) {
+        const { account, vault, shares, owner, swapQuote } = args;
+        const batchItems = this.encodeRedeemAndSwap({
+            chainId: account.chainId,
+            vault,
+            shares,
+            owner,
+            sender: account.owner,
+            swapQuote,
+        });
+        return this.convertBatchItemsToPlan(batchItems, "redeemAndSwap");
+    }
     /**
      * Builds a transaction plan for swapping collateral from one vault to another (withdraw → swap → deposit/skim).
      *
@@ -1384,7 +1681,7 @@ export class ExecutionService {
      * @returns Array of transaction plan items (EVC batch: withdraw, swap, verify/skim, optional enable/disable collateral)
      */
     planSwapCollateral(args) {
-        const { swapQuote, account } = args;
+        const { swapQuote, account, swapperMode } = args;
         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
@@ -1403,6 +1700,7 @@ export class ExecutionService {
             enableCollateral,
             disableCollateralOnMax: true,
             isMax,
+            swapperMode,
         });
         plan.push(...this.convertBatchItemsToPlan(batchItems, "swapCollateral"));
         return plan;
@@ -1416,7 +1714,7 @@ export class ExecutionService {
      * @returns Array of transaction plan items (EVC batch: enableController, borrow, swap, verify/repay, optional disableController)
      */
     planSwapDebt(args) {
-        const { swapQuote, account } = args;
+        const { swapQuote, account, swapperMode } = args;
         const plan = [];
         const sourcePosition = account?.getPosition(swapQuote.accountIn, swapQuote.vaultIn);
         const isMax = sourcePosition
@@ -1431,6 +1729,7 @@ export class ExecutionService {
             enableController,
             disableControllerOnMax: true,
             isMax,
+            swapperMode,
         });
         plan.push(...this.convertBatchItemsToPlan(batchItems, "swapDebt"));
         return plan;
@@ -1602,7 +1901,7 @@ export class ExecutionService {
      * @returns Array of transaction plan items (optional approval + EVC batch). Throws if swapQuote.accountIn !== swapQuote.accountOut.
      */
     planMultiplyWithSwap(args) {
-        const { collateralVault, collateralAmount, collateralAsset, collateralShareSource, account, swapQuote, } = args;
+        const { collateralVault, collateralAmount, collateralAsset, collateralShareSource, collateralWrappedNativeInfo, account, swapQuote, swapperMode, } = args;
         const plan = [];
         // 1. Check if collateral approval is needed (only if depositing collateral)
         if (!collateralShareSource && collateralAmount > 0n) {
@@ -1621,13 +1920,14 @@ export class ExecutionService {
         const receiver = swapQuote.accountIn;
         const liabilityVault = swapQuote.vaultIn;
         const longVault = swapQuote.receiver;
-        const liabilityAmount = BigInt(swapQuote.amountIn);
+        const liabilityAmount = getSwapInputAmount(swapQuote, swapperMode ?? SwapperMode.EXACT_IN);
         // 2. Determine if collateral needs to be enabled
         const hasCollateralInput = collateralShareSource
             ? collateralShareSource.shares > 0n
             : collateralAmount > 0n;
         const enableCollateral = hasCollateralInput &&
             !(account?.isCollateralEnabled(receiver, collateralVault) ?? false);
+        const enableCollateralLong = !(account?.isCollateralEnabled(receiver, longVault) ?? false);
         const resolvedCollateralShareSource = collateralShareSource
             ? {
                 ...collateralShareSource,
@@ -1654,7 +1954,9 @@ export class ExecutionService {
             currentController: currentController || undefined,
             enableController,
             collateralShareSource: resolvedCollateralShareSource,
+            collateralWrappedNativeInfo,
             swapQuote,
+            enableCollateralLong,
             // Permit2 is handled separately in the plan
         });
         plan.push(...this.convertBatchItemsToPlan(batchItems, "multiplyWithSwap"));
@@ -1676,7 +1978,7 @@ export class ExecutionService {
      * @returns Array of transaction plan items (optional approval + EVC batch)
      */
     planMultiplySameAsset(args) {
-        const { collateralVault, collateralAmount, collateralAsset, collateralShareSource, liabilityVault, liabilityAmount, longVault, receiver, account, } = args;
+        const { collateralVault, collateralAmount, collateralAsset, collateralShareSource, collateralWrappedNativeInfo, liabilityVault, liabilityAmount, longVault, receiver, account, } = args;
         const plan = [];
         // 1. Check if collateral approval is needed (only if depositing collateral)
         if (!collateralShareSource && collateralAmount > 0n) {
@@ -1695,6 +1997,7 @@ export class ExecutionService {
             : collateralAmount > 0n;
         const enableCollateral = hasCollateralInput &&
             !(account?.isCollateralEnabled(receiver, collateralVault) ?? false);
+        const enableCollateralLong = !(account?.isCollateralEnabled(receiver, longVault) ?? false);
         const resolvedCollateralShareSource = collateralShareSource
             ? {
                 ...collateralShareSource,
@@ -1721,6 +2024,8 @@ export class ExecutionService {
             currentController: currentController || undefined,
             enableController,
             collateralShareSource: resolvedCollateralShareSource,
+            collateralWrappedNativeInfo,
+            enableCollateralLong,
             // Permit2 is handled separately in the plan
         });
         plan.push(...this.convertBatchItemsToPlan(batchItems, "multiplySameAsset"));