@eulerxyz/euler-v2-sdk 0.2.6-beta → 0.2.8-beta

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

@@ -2,6 +2,7 @@ import { decodeFunctionData, encodeFunctionData, erc20Abi, getAddress, maxUint16
 import { resolveBorrowCollateralPositions } from "../../utils/accountPositionClassification.js";
 import { SwapperMode } from "../swapService/swapServiceTypes.js";
 import { adjustForInterest, getSwapInputAmount, } from "../swapService/swapVerification.js";
+import { isEVault, } from "../vaults/vaultMetaService/index.js";
 import { ethereumVaultConnectorAbi } from "./abis/ethereumVaultConnectorAbi.js";
 import { eVaultAbi } from "./abis/eVaultAbi.js";
 import { permit2PermitAbi } from "./abis/permit2PermitAbi.js";
@@ -252,6 +253,7 @@ export class ExecutionService {
     intrinsicApyService;
     eulerLabelsService;
     processPlugins;
+    prefetchPlugins;
     constructor(deploymentService, walletService, providerService, vaultMetaService, priceService, rewardsService, intrinsicApyService, eulerLabelsService) {
         this.deploymentService = deploymentService;
         this.walletService = walletService;
@@ -289,6 +291,9 @@ export class ExecutionService {
     setPluginProcessor(processPlugins) {
         this.processPlugins = processPlugins;
     }
+    setPluginPrefetcher(prefetchPlugins) {
+        this.prefetchPlugins = prefetchPlugins;
+    }
     /** Derive storage overrides needed to simulate the plan against the current account state. */
     async deriveStateOverrides(chainId, account, transactionPlan, options) {
         assertNoCowSwapPlanItems(transactionPlan, "deriveStateOverrides");
@@ -297,7 +302,7 @@ export class ExecutionService {
     /** 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 processedPlan = await this.processPlanPlugins(transactionPlan, account, chainId, options?.prefetch);
         const owner = this.getAccountOwner(account);
         return simulateTransactionPlan(this.getSimulationContext(), chainId, owner, processedPlan, options);
     }
@@ -319,9 +324,9 @@ export class ExecutionService {
      * wallet allowances.
      */
     async prepareTransactionPlan(args) {
-        const { plan, chainId, account, usePermit2 = true, unlimitedApproval = false, } = args;
+        const { plan, chainId, account, usePermit2 = true, unlimitedApproval = false, prefetch, } = args;
         assertNoCowSwapPlanItems(plan, "prepareTransactionPlan");
-        const processedPlan = await this.processPlanPlugins(plan, account, chainId);
+        const processedPlan = await this.processPlanPlugins(plan, account, chainId, prefetch);
         const owner = this.getAccountOwner(account);
         const resolvedPlan = await this.resolveRequiredApprovals({
             plan: processedPlan,
@@ -342,10 +347,24 @@ export class ExecutionService {
     /** 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 processedPlan = await this.processPlanPlugins(transactionPlan, account, chainId, options?.prefetch);
         const owner = this.getAccountOwner(account);
         return estimateGasForTransactionPlan(this.getSimulationContext(), chainId, owner, processedPlan, options);
     }
+    /**
+     * Estimate gas for a {@link TransactionPlanPrepared} envelope. Plugins and
+     * approval resolution were already applied by {@link prepareTransactionPlan},
+     * so this skips the plugin pipeline (TOS / Keyring / Pyth) entirely — the
+     * plan's batch items are used as-is. Net effect: per-call gas estimate
+     * drops from "plugin pipeline + estimate" to just the estimate, mirroring
+     * the simulatePreparedTransactionPlan / executePreparedTransactionPlan
+     * pattern.
+     */
+    async estimateGasForPreparedTransactionPlan(prepared, options) {
+        assertNoCowSwapPlanItems(prepared.plan, "estimateGasForPreparedTransactionPlan");
+        const owner = this.getAccountOwner(prepared.account);
+        return estimateGasForTransactionPlan(this.getSimulationContext(), prepared.chainId, owner, prepared.plan, options);
+    }
     /** Execute a transaction plan using caller-provided signing and send callbacks. */
     async executeTransactionPlan(args) {
         const { providerService } = this;
@@ -353,7 +372,7 @@ export class ExecutionService {
             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);
+        const processedPlan = await this.processPlanPlugins(args.plan, args.account, args.chainId, args.prefetch);
         assertNoCowSwapPlanItems(processedPlan, "executeTransactionPlan");
         const helperArgs = {
             ...args,
@@ -399,7 +418,7 @@ export class ExecutionService {
         }
         return executeCowSwapTransactionPlan({
             ...args,
-            plan: await this.processPlanPlugins(args.plan, args.account, args.chainId),
+            plan: await this.processPlanPlugins(args.plan, args.account, args.chainId, args.prefetch),
             deploymentService: this.deploymentService,
             providerService,
         });
@@ -417,11 +436,31 @@ export class ExecutionService {
             describeBatch: (batch) => this.describeBatch(batch),
         };
     }
-    async processPlanPlugins(plan, account, chainId) {
+    /**
+     * Run each plugin's processPlan in registration order. Plugins receive the
+     * plan as modified by previous plugins; errors are caught per-plugin so a
+     * single failing plugin can't poison the pipeline.
+     *
+     * `prefetch` carries form-level data each plugin pre-resolved via
+     * {@link prefetchPluginDataForPlan} — passing it lets the plugin skip its
+     * own network I/O (Hermes pulls, keyring hook reads, etc.).
+     */
+    async processPlanPlugins(plan, account, chainId, prefetch) {
         return this.processPlugins
-            ? this.processPlugins(plan, account, chainId)
+            ? this.processPlugins(plan, account, chainId, prefetch)
             : plan;
     }
+    /**
+     * Resolve each plugin's prefetch payload for a given plan once, so per-quote
+     * prepare/estimate/simulate calls can reuse the data instead of refetching.
+     * Returns an open record keyed by plugin name — known SDK slots are typed
+     * (`pyth`, `keyring`); external plugins populate their own keys.
+     */
+    async prefetchPluginDataForPlan(plan, account, chainId) {
+        return this.prefetchPlugins
+            ? this.prefetchPlugins(plan, account, chainId)
+            : {};
+    }
     getAccountOwner(account) {
         return typeof account === "string" ? account : account.owner;
     }
@@ -1033,10 +1072,19 @@ export class ExecutionService {
         const transferredPositions = new Set();
         for (const collateral of activeCollaterals) {
             batchItems.push(this.encodeDisableCollateral(account.chainId, receiver, collateral.vaultAddress));
-            if (getAddress(receiver) !== getAddress(account.owner)) {
+            // Only EVK vaults expose the transferFromMax used by the cleanup
+            // sweep. Other vault types (e.g. Securitize RWA collaterals) don't
+            // implement it and the underlying transfer would revert against the
+            // ERC-20 whitelist anyway, taking the whole repay batch down. The
+            // disable step above still runs for every active collateral.
+            const isEvkCollateral = isEVault(collateral.vault);
+            if (isEvkCollateral &&
+                getAddress(receiver) !== getAddress(account.owner)) {
                 batchItems.push(this.encodeTransferFromMax(collateral.vaultAddress, receiver, account.owner));
             }
-            transferredPositions.add(`${getAddress(receiver)}:${getAddress(collateral.vaultAddress)}`);
+            if (isEvkCollateral) {
+                transferredPositions.add(`${getAddress(receiver)}:${getAddress(collateral.vaultAddress)}`);
+            }
         }
         if (sourceAccount && sourceVault) {
             const sourcePositionKey = `${getAddress(sourceAccount)}:${getAddress(sourceVault)}`;
@@ -1113,6 +1161,14 @@ export class ExecutionService {
                     continue;
                 }
                 if (usePermit2) {
+                    // Skip Permit2 entirely when an existing direct token→vault
+                    // allowance already covers the requirement. Avoids prompting
+                    // the user for a Permit2 approve+signature when a prior
+                    // direct ERC-20 approval is sufficient.
+                    if (allowances.assetForVault >= amount) {
+                        approval.resolved = [];
+                        continue;
+                    }
                     // Check permit2 allowances
                     const assetForPermit2 = allowances.assetForPermit2;
                     const assetForVaultInPermit2 = allowances.assetForVaultInPermit2;
@@ -1204,45 +1260,58 @@ export class ExecutionService {
             unlimitedApproval,
         });
     }
-    // ========== 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;
+    buildCleanupBatchItems(account, subAccount, options = {}) {
+        const { skipCollateralCleanup = false, controllerToKeep } = options;
+        const normalizedControllerToKeep = controllerToKeep
+            ? getAddress(controllerToKeep)
+            : undefined;
+        const empty = () => ({
+            items: [],
+            disabledControllers: new Set(),
+            disabledCollaterals: new Set(),
+        });
         if (typeof account.getSubAccount !== "function")
-            return [];
+            return empty();
         const subAccountSnapshot = account.getSubAccount(subAccount);
         if (!subAccountSnapshot)
-            return [];
+            return empty();
         const collaterals = subAccountSnapshot.enabledCollaterals ?? [];
         const controllers = subAccountSnapshot.enabledControllers ?? [];
         if (collaterals.length === 0 && controllers.length === 0)
-            return [];
+            return empty();
         const items = [];
+        const disabledControllers = new Set();
+        const disabledCollaterals = new Set();
+        const disableCollateral = (collateral) => {
+            if (skipCollateralCleanup)
+                return;
+            const normalizedCollateral = getAddress(collateral);
+            disabledCollaterals.add(normalizedCollateral);
+            items.push(this.encodeDisableCollateral(account.chainId, subAccount, normalizedCollateral));
+        };
         const disableAllCollaterals = () => {
             for (const collateral of collaterals) {
-                items.push(this.encodeDisableCollateral(account.chainId, subAccount, collateral));
+                disableCollateral(collateral);
             }
         };
+        const disableController = (controller) => {
+            const normalizedController = getAddress(controller);
+            if (normalizedController === normalizedControllerToKeep)
+                return;
+            disabledControllers.add(normalizedController);
+            items.push(this.encodeDisableController(normalizedController, subAccount));
+        };
         if (controllers.length === 0) {
             disableAllCollaterals();
-            return this.convertBatchItemsToPlan(items, "cleanup");
+            return { items, disabledControllers, disabledCollaterals };
         }
         const hasActiveBorrow = subAccountSnapshot.positions.some((position) => position.borrowed > 0n);
         if (!hasActiveBorrow) {
             disableAllCollaterals();
             for (const controller of controllers) {
-                items.push(this.encodeDisableController(controller, subAccount));
+                disableController(controller);
             }
-            return this.convertBatchItemsToPlan(items, "cleanup");
+            return { items, disabledControllers, disabledCollaterals };
         }
         const depositedVaults = new Set(subAccountSnapshot.positions
             .filter(hasSuppliedPosition)
@@ -1250,9 +1319,25 @@ export class ExecutionService {
         for (const collateral of collaterals) {
             if (depositedVaults.has(getAddress(collateral)))
                 continue;
-            items.push(this.encodeDisableCollateral(account.chainId, subAccount, collateral));
+            disableCollateral(collateral);
         }
-        return this.convertBatchItemsToPlan(items, "cleanup");
+        return { items, disabledControllers, disabledCollaterals };
+    }
+    // ========== 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;
+        const cleanup = this.buildCleanupBatchItems(account, subAccount);
+        return this.convertBatchItemsToPlan(cleanup.items, "cleanup");
     }
     /**
      * Builds a transaction plan for depositing assets into a vault.
@@ -1430,8 +1515,18 @@ export class ExecutionService {
      * @returns Array of transaction plan items (optional approval + EVC batch)
      */
     planBorrow(args) {
-        const { vault, amount, receiver, borrowAccount, account, collateral } = args;
+        const { vault, amount, receiver, borrowAccount, account, collateral, skipCleanup = false, } = args;
         const plan = [];
+        const cleanup = skipCleanup
+            ? {
+                items: [],
+                disabledControllers: new Set(),
+                disabledCollaterals: new Set(),
+            }
+            : this.buildCleanupBatchItems(account, borrowAccount, {
+                skipCollateralCleanup: true,
+                controllerToKeep: vault,
+            });
         const savingsCollateral = isSavingsCollateral(collateral)
             ? collateral
             : undefined;
@@ -1439,13 +1534,19 @@ export class ExecutionService {
             ? collateral
             : undefined;
         const enableCollateral = collateral && collateral.amount > 0n
-            ? !(account?.isCollateralEnabled(borrowAccount, collateral.vault) ??
-                false)
+            ? cleanup.disabledCollaterals.has(getAddress(collateral.vault)) ||
+                !(account?.isCollateralEnabled(borrowAccount, collateral.vault) ??
+                    false)
             : false;
         // Check if controller needs to be enabled
         // Default: controller is not enabled when account/sub-account is not available
-        const currentController = account?.getCurrentController(borrowAccount);
-        const enableController = !(account?.isControllerEnabled(borrowAccount, vault) ?? false);
+        const currentControllerBeforeCleanup = account?.getCurrentController(borrowAccount);
+        const currentController = currentControllerBeforeCleanup &&
+            !cleanup.disabledControllers.has(getAddress(currentControllerBeforeCleanup))
+            ? currentControllerBeforeCleanup
+            : undefined;
+        const enableController = cleanup.disabledControllers.size > 0 ||
+            !(account?.isControllerEnabled(borrowAccount, vault) ?? false);
         if (walletCollateral && walletCollateral.amount > 0n) {
             // Approval is needed from the account owner (who owns the wallet tokens)
             // Add approval requirement (will be resolved later with Wallet data)
@@ -1457,29 +1558,32 @@ export class ExecutionService {
                 amount: walletCollateral.amount,
             });
         }
-        const batchItems = this.encodeBorrow({
-            chainId: account.chainId,
-            vault,
-            amount,
-            owner: account.owner,
-            borrowAccount,
-            receiver,
-            enableController,
-            currentController: currentController || undefined,
-            enableCollateral,
-            collateralVault: collateral?.vault,
-            collateralAmount: walletCollateral?.amount,
-            collateralWrappedNativeInfo: walletCollateral?.wrappedNativeInfo,
-            collateralShareSource: savingsCollateral
-                ? {
-                    from: savingsCollateral.from,
-                    shares: savingsCollateral.amount,
-                    disableCollateralFrom: savingsCollateral.disableCollateralFrom &&
-                        (account?.isCollateralEnabled(savingsCollateral.from, savingsCollateral.vault) ??
-                            false),
-                }
-                : undefined,
-        });
+        const batchItems = [
+            ...cleanup.items,
+            ...this.encodeBorrow({
+                chainId: account.chainId,
+                vault,
+                amount,
+                owner: account.owner,
+                borrowAccount,
+                receiver,
+                enableController,
+                currentController: currentController || undefined,
+                enableCollateral,
+                collateralVault: collateral?.vault,
+                collateralAmount: walletCollateral?.amount,
+                collateralWrappedNativeInfo: walletCollateral?.wrappedNativeInfo,
+                collateralShareSource: savingsCollateral
+                    ? {
+                        from: savingsCollateral.from,
+                        shares: savingsCollateral.amount,
+                        disableCollateralFrom: savingsCollateral.disableCollateralFrom &&
+                            (account?.isCollateralEnabled(savingsCollateral.from, savingsCollateral.vault) ??
+                                false),
+                    }
+                    : undefined,
+            }),
+        ];
         plan.push(...this.convertBatchItemsToPlan(batchItems, "borrow"));
         return plan;
     }
@@ -1862,9 +1966,16 @@ export class ExecutionService {
         return plan;
     }
     planSwapAndBorrowFromWallet(args) {
-        const { swapQuote, amount, tokenIn, account, borrowVault, borrowAmount, borrowAccount = swapQuote.accountOut, receiver = account.owner, collateralVault = swapQuote.receiver, wrappedNativeInfo, } = args;
+        const { swapQuote, amount, tokenIn, account, borrowVault, borrowAmount, borrowAccount = swapQuote.accountOut, receiver = account.owner, collateralVault = swapQuote.receiver, wrappedNativeInfo, skipCleanup = false, } = args;
         assertNonCowSwapQuote(swapQuote, "planSwapAndBorrowFromWallet");
         const plan = [];
+        const cleanup = skipCleanup
+            ? {
+                items: [],
+                disabledControllers: new Set(),
+                disabledCollaterals: new Set(),
+            }
+            : this.buildCleanupBatchItems(account, borrowAccount);
         plan.push({
             type: "requiredApproval",
             token: tokenIn,
@@ -1872,24 +1983,33 @@ export class ExecutionService {
             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,
-        });
+        const enableController = cleanup.disabledControllers.size > 0 ||
+            !(account?.isControllerEnabled(borrowAccount, borrowVault) ?? false);
+        const enableCollateral = cleanup.disabledCollaterals.has(getAddress(collateralVault)) ||
+            !(account?.isCollateralEnabled(borrowAccount, collateralVault) ?? false);
+        const currentControllerBeforeCleanup = account?.getCurrentController(borrowAccount);
+        const currentController = currentControllerBeforeCleanup &&
+            !cleanup.disabledControllers.has(getAddress(currentControllerBeforeCleanup))
+            ? currentControllerBeforeCleanup
+            : undefined;
+        const batchItems = [
+            ...cleanup.items,
+            ...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;
     }
@@ -2229,7 +2349,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, collateralWrappedNativeInfo, account, swapQuote, swapperMode, } = args;
+        const { collateralVault, collateralAmount, collateralAsset, collateralShareSource, collateralWrappedNativeInfo, account, swapQuote, swapperMode, skipCleanup = false, } = args;
         assertNonCowSwapQuote(swapQuote, "planMultiplyWithSwap", "planOpenPositionWithCoW");
         const plan = [];
         // 1. Check if collateral approval is needed (only if depositing collateral)
@@ -2249,14 +2369,23 @@ export class ExecutionService {
         const receiver = swapQuote.accountIn;
         const liabilityVault = swapQuote.vaultIn;
         const longVault = swapQuote.receiver;
+        const cleanup = skipCleanup
+            ? {
+                items: [],
+                disabledControllers: new Set(),
+                disabledCollaterals: new Set(),
+            }
+            : this.buildCleanupBatchItems(account, receiver);
         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);
+            (cleanup.disabledCollaterals.has(getAddress(collateralVault)) ||
+                !(account?.isCollateralEnabled(receiver, collateralVault) ?? false));
+        const enableCollateralLong = cleanup.disabledCollaterals.has(getAddress(longVault)) ||
+            !(account?.isCollateralEnabled(receiver, longVault) ?? false);
         const resolvedCollateralShareSource = collateralShareSource
             ? {
                 ...collateralShareSource,
@@ -2266,28 +2395,36 @@ export class ExecutionService {
             }
             : undefined;
         // 3. Determine if controller needs to be enabled
-        const enableController = !(account?.isControllerEnabled(receiver, liabilityVault) ?? false);
+        const enableController = cleanup.disabledControllers.size > 0 ||
+            !(account?.isControllerEnabled(receiver, liabilityVault) ?? false);
         // 4. Get current controller (may need to disable if different)
-        const currentController = account?.getCurrentController(receiver);
+        const currentControllerBeforeCleanup = account?.getCurrentController(receiver);
+        const currentController = currentControllerBeforeCleanup &&
+            !cleanup.disabledControllers.has(getAddress(currentControllerBeforeCleanup))
+            ? currentControllerBeforeCleanup
+            : undefined;
         // 5. Build EVC batch items
-        const batchItems = this.encodeMultiplyWithSwap({
-            chainId: account.chainId,
-            collateralVault,
-            collateralAmount,
-            liabilityVault,
-            liabilityAmount,
-            longVault,
-            owner: account.owner,
-            receiver,
-            enableCollateral,
-            currentController: currentController || undefined,
-            enableController,
-            collateralShareSource: resolvedCollateralShareSource,
-            collateralWrappedNativeInfo,
-            swapQuote,
-            enableCollateralLong,
-            // Permit2 is handled separately in the plan
-        });
+        const batchItems = [
+            ...cleanup.items,
+            ...this.encodeMultiplyWithSwap({
+                chainId: account.chainId,
+                collateralVault,
+                collateralAmount,
+                liabilityVault,
+                liabilityAmount,
+                longVault,
+                owner: account.owner,
+                receiver,
+                enableCollateral,
+                currentController: currentController || undefined,
+                enableController,
+                collateralShareSource: resolvedCollateralShareSource,
+                collateralWrappedNativeInfo,
+                swapQuote,
+                enableCollateralLong,
+                // Permit2 is handled separately in the plan
+            }),
+        ];
         plan.push(...this.convertBatchItemsToPlan(batchItems, "multiplyWithSwap"));
         return plan;
     }
@@ -2348,8 +2485,15 @@ export class ExecutionService {
      * @returns Array of transaction plan items (optional approval + EVC batch)
      */
     planMultiplySameAsset(args) {
-        const { collateralVault, collateralAmount, collateralAsset, collateralShareSource, collateralWrappedNativeInfo, liabilityVault, liabilityAmount, longVault, receiver, account, } = args;
+        const { collateralVault, collateralAmount, collateralAsset, collateralShareSource, collateralWrappedNativeInfo, liabilityVault, liabilityAmount, longVault, receiver, account, skipCleanup = false, } = args;
         const plan = [];
+        const cleanup = skipCleanup
+            ? {
+                items: [],
+                disabledControllers: new Set(),
+                disabledCollaterals: new Set(),
+            }
+            : this.buildCleanupBatchItems(account, receiver);
         // 1. Check if collateral approval is needed (only if depositing collateral)
         if (!collateralShareSource && collateralAmount > 0n) {
             // Add approval requirement (will be resolved later with Wallet data)
@@ -2366,8 +2510,10 @@ export class ExecutionService {
             ? collateralShareSource.shares > 0n
             : collateralAmount > 0n;
         const enableCollateral = hasCollateralInput &&
-            !(account?.isCollateralEnabled(receiver, collateralVault) ?? false);
-        const enableCollateralLong = !(account?.isCollateralEnabled(receiver, longVault) ?? false);
+            (cleanup.disabledCollaterals.has(getAddress(collateralVault)) ||
+                !(account?.isCollateralEnabled(receiver, collateralVault) ?? false));
+        const enableCollateralLong = cleanup.disabledCollaterals.has(getAddress(longVault)) ||
+            !(account?.isCollateralEnabled(receiver, longVault) ?? false);
         const resolvedCollateralShareSource = collateralShareSource
             ? {
                 ...collateralShareSource,
@@ -2377,27 +2523,35 @@ export class ExecutionService {
             }
             : undefined;
         // 3. Determine if controller needs to be enabled
-        const enableController = !(account?.isControllerEnabled(receiver, liabilityVault) ?? false);
+        const enableController = cleanup.disabledControllers.size > 0 ||
+            !(account?.isControllerEnabled(receiver, liabilityVault) ?? false);
         // 4. Get current controller (may need to disable if different)
-        const currentController = account?.getCurrentController(receiver);
+        const currentControllerBeforeCleanup = account?.getCurrentController(receiver);
+        const currentController = currentControllerBeforeCleanup &&
+            !cleanup.disabledControllers.has(getAddress(currentControllerBeforeCleanup))
+            ? currentControllerBeforeCleanup
+            : undefined;
         // 5. Build EVC batch items
-        const batchItems = this.encodeMultiplySameAsset({
-            chainId: account.chainId,
-            collateralVault,
-            collateralAmount,
-            liabilityVault,
-            liabilityAmount,
-            longVault,
-            owner: account.owner,
-            receiver,
-            enableCollateral,
-            currentController: currentController || undefined,
-            enableController,
-            collateralShareSource: resolvedCollateralShareSource,
-            collateralWrappedNativeInfo,
-            enableCollateralLong,
-            // Permit2 is handled separately in the plan
-        });
+        const batchItems = [
+            ...cleanup.items,
+            ...this.encodeMultiplySameAsset({
+                chainId: account.chainId,
+                collateralVault,
+                collateralAmount,
+                liabilityVault,
+                liabilityAmount,
+                longVault,
+                owner: account.owner,
+                receiver,
+                enableCollateral,
+                currentController: currentController || undefined,
+                enableController,
+                collateralShareSource: resolvedCollateralShareSource,
+                collateralWrappedNativeInfo,
+                enableCollateralLong,
+                // Permit2 is handled separately in the plan
+            }),
+        ];
         plan.push(...this.convertBatchItemsToPlan(batchItems, "multiplySameAsset"));
         return plan;
     }