@eulerxyz/euler-v2-sdk 0.2.0-beta → 0.2.2-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,124 @@ function cloneBatchEntries(entries) {
         ? { type: "operation", name: entry.name, items: [...entry.items] }
         : entry);
 }
+function hasSuppliedPosition(position) {
+    return position.assets > 0n || position.shares > 0n;
+}
+function hasShareConversion(vault) {
+    return (typeof vault === "object" &&
+        vault !== null &&
+        "convertToShares" in vault &&
+        typeof vault.convertToShares === "function");
+}
+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.
@@ -399,6 +519,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).
@@ -531,7 +664,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) {
@@ -658,7 +791,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.
@@ -738,11 +877,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) {
@@ -783,7 +922,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 {
@@ -810,7 +949,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 {
@@ -880,6 +1019,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.
@@ -894,7 +1082,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;
@@ -914,6 +1102,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"));
@@ -933,7 +1122,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;
@@ -956,6 +1145,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"));
@@ -992,11 +1182,13 @@ export class ExecutionService {
     }
     /**
      * Builds a transaction plan for redeeming vault shares for underlying assets.
+     * Pass `shares` directly, or pass `assets` to derive shares from the account's populated vault state.
      * Use `maxUint256` for `shares` to redeem all available shares.
      *
      * @param args - Redeem plan arguments
      * @param args.vault - Address of the vault to redeem shares from
      * @param args.shares - Number of vault shares to redeem (use maxUint256 for "redeem all")
+     * @param args.assets - Underlying asset amount used to calculate shares from the account vault snapshot
      * @param args.owner - Sub-account address whose shares are being redeemed
      * @param args.receiver - Address that will receive the underlying assets
      * @param args.account - Account entity; used for chainId and position/collateral state
@@ -1004,10 +1196,11 @@ export class ExecutionService {
      * @returns Array of transaction plan items (EVC batch; no approvals needed for redeem)
      */
     planRedeem(args) {
-        const { vault, shares, 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);
+        const shares = this.resolveRedeemShares(args, position);
         // Build EVC batch items
         const batchItems = this.encodeRedeem({
             chainId: account.chainId,
@@ -1020,6 +1213,19 @@ export class ExecutionService {
         plan.push(...this.convertBatchItemsToPlan(batchItems, "redeem"));
         return plan;
     }
+    resolveRedeemShares(args, position) {
+        if ("shares" in args && args.shares !== undefined)
+            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.");
+        }
+        // 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);
+    }
     /**
      * Builds a transaction plan for borrowing from a liability vault.
      * Use `maxUint256` for `collateral.amount` to deposit all available collateral asset from the wallet.
@@ -1076,6 +1282,7 @@ export class ExecutionService {
             enableCollateral,
             collateralVault: collateral?.vault,
             collateralAmount: walletCollateral?.amount,
+            collateralWrappedNativeInfo: walletCollateral?.wrappedNativeInfo,
             collateralShareSource: savingsCollateral
                 ? {
                     from: savingsCollateral.from,
@@ -1153,15 +1360,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,
@@ -1288,7 +1496,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);
@@ -1306,6 +1514,7 @@ export class ExecutionService {
             maxWithdraw,
             isMax,
             disableControllerOnMax: true,
+            swapperMode,
         });
         if (cleanupOnMax && isMax) {
             this.appendMaxRepayCleanup({
@@ -1334,7 +1543,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({
@@ -1358,6 +1567,7 @@ export class ExecutionService {
             amount,
             sender: account.owner,
             enableCollateral: shouldEnableCollateral,
+            wrappedNativeInfo,
         });
         plan.push(...this.convertBatchItemsToPlan(batchItems, "depositWithSwapFromWallet"));
         return plan;
@@ -1374,7 +1584,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",
@@ -1388,10 +1598,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).
      *
@@ -1401,7 +1703,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
@@ -1420,6 +1722,7 @@ export class ExecutionService {
             enableCollateral,
             disableCollateralOnMax: true,
             isMax,
+            swapperMode,
         });
         plan.push(...this.convertBatchItemsToPlan(batchItems, "swapCollateral"));
         return plan;
@@ -1433,11 +1736,11 @@ 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
-            ? sourcePosition.borrowed <= BigInt(swapQuote.amountOutMin)
+        const liabilityPosition = account?.getPosition(swapQuote.accountIn, swapQuote.receiver);
+        const isMax = liabilityPosition
+            ? liabilityPosition.borrowed <= BigInt(swapQuote.amountOutMin)
             : false;
         const enableController = !(account?.isControllerEnabled(swapQuote.accountOut, swapQuote.vaultIn) ??
             false);
@@ -1448,6 +1751,7 @@ export class ExecutionService {
             enableController,
             disableControllerOnMax: true,
             isMax,
+            swapperMode,
         });
         plan.push(...this.convertBatchItemsToPlan(batchItems, "swapDebt"));
         return plan;
@@ -1510,7 +1814,7 @@ export class ExecutionService {
      * @param args.liabilityAmount - Current debt amount; defaults to the old-vault borrowed amount in account data
      * @param args.oldLiabilityAsset - Optional old liability asset; defaults to the old-vault account position asset
      * @param args.newLiabilityAsset - New liability underlying asset, used to verify this is a same-asset migration
-     * @param args.sweepExcess - Whether to redeem and skim the migration cushion back into the new vault (default true)
+     * @param args.sweepExcess - Whether to redeem and skim the migration cushion back into the new vault when the old vault has no pre-existing supplied shares (default true)
      * @param args.transferRemainingSharesToOwner - Whether to transfer new-vault shares to the owner when liabilityAccount differs from owner (default true)
      * @returns Array of transaction plan items (EVC batch; no token approvals)
      */
@@ -1534,6 +1838,7 @@ export class ExecutionService {
             getAddress(liabilityAccount) !== getAddress(account.owner)
             ? account.owner
             : undefined;
+        const shouldSweepExcess = sweepExcess && !(oldPosition && hasSuppliedPosition(oldPosition));
         const batchItems = this.encodeMigrateSameAssetDebt({
             chainId: account.chainId,
             oldLiabilityVault,
@@ -1542,7 +1847,7 @@ export class ExecutionService {
             account: liabilityAccount,
             enableController,
             disableController: true,
-            sweepExcess,
+            sweepExcess: shouldSweepExcess,
             transferRemainingSharesTo,
         });
         plan.push(...this.convertBatchItemsToPlan(batchItems, "migrateSameAssetDebt"));
@@ -1619,7 +1924,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) {
@@ -1638,13 +1943,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,
@@ -1671,7 +1977,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"));
@@ -1693,7 +2001,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) {
@@ -1712,6 +2020,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,
@@ -1738,6 +2047,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"));