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

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

@@ -1,28 +1,120 @@
-import { encodeFunctionData, getAddress, maxUint256, zeroAddress, maxUint160, maxUint48, erc20Abi, decodeFunctionData, } from "viem";
+import { decodeFunctionData, encodeFunctionData, erc20Abi, getAddress, maxUint256, maxUint160, } from "viem";
+import { resolveBorrowCollateralPositions } from "../../utils/accountPositionClassification.js";
 import { ethereumVaultConnectorAbi } from "./abis/ethereumVaultConnectorAbi.js";
 import { eVaultAbi } from "./abis/eVaultAbi.js";
 import { permit2PermitAbi } from "./abis/permit2PermitAbi.js";
 import { swapperAbi } from "./abis/swapperAbi.js";
 import { swapVerifierAbi } from "./abis/swapVerifierAbi.js";
-import { PERMIT2_TYPES, } from "./executionServiceTypes.js";
-const PERMIT2_SIG_WINDOW = 60n * 60n;
+import * as encodeHelpers from "./encode.js";
+import { isEVCBatchOperation } from "./executionServiceTypes.js";
+import { executeTransactionPlan, } from "./execute.js";
+import { deriveStateOverrides, estimateGasForTransactionPlan, simulateTransactionPlan, } from "./simulate.js";
+const TOKENS_REQUIRING_ZERO_APPROVAL_RESET = {
+    1: [getAddress("0xdAC17F958D2ee523a2206206994597C13D831ec7")],
+};
+function requiresZeroApprovalReset(chainId, token) {
+    return (TOKENS_REQUIRING_ZERO_APPROVAL_RESET[chainId]?.some((resetToken) => resetToken === getAddress(token)) ?? false);
+}
+function isSavingsCollateral(collateral) {
+    return collateral?.source === "savings";
+}
+function isWalletCollateral(collateral) {
+    return !!collateral && !isSavingsCollateral(collateral);
+}
+function cloneBatchEntries(entries) {
+    return entries.map((entry) => "type" in entry && entry.type === "operation"
+        ? { type: "operation", name: entry.name, items: [...entry.items] }
+        : entry);
+}
 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.
 export class ExecutionService {
     deploymentService;
-    walletService;
     plugins = [];
-    constructor(deploymentService, walletService) {
+    walletService;
+    providerService;
+    vaultMetaService;
+    priceService;
+    rewardsService;
+    intrinsicApyService;
+    eulerLabelsService;
+    constructor(deploymentService, walletService, providerService, vaultMetaService, priceService, rewardsService, intrinsicApyService, eulerLabelsService) {
         this.deploymentService = deploymentService;
         this.walletService = walletService;
+        this.providerService = providerService;
+        this.vaultMetaService = vaultMetaService;
+        this.priceService = priceService;
+        this.rewardsService = rewardsService;
+        this.intrinsicApyService = intrinsicApyService;
+        this.eulerLabelsService = eulerLabelsService;
     }
     setWalletService(walletService) {
         this.walletService = walletService;
     }
+    setProviderService(providerService) {
+        this.providerService = providerService;
+    }
+    setVaultMetaService(vaultMetaService) {
+        this.vaultMetaService = vaultMetaService;
+    }
+    setPriceService(priceService) {
+        this.priceService = priceService;
+    }
+    setRewardsService(rewardsService) {
+        this.rewardsService = rewardsService;
+    }
+    setIntrinsicApyService(intrinsicApyService) {
+        this.intrinsicApyService = intrinsicApyService;
+    }
+    setEulerLabelsService(eulerLabelsService) {
+        this.eulerLabelsService = eulerLabelsService;
+    }
     setPlugins(plugins) {
         this.plugins = plugins;
     }
+    /** 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);
+    }
+    /** 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);
+    }
+    /** Execute a transaction plan using caller-provided signing and send callbacks. */
+    async executeTransactionPlan(args) {
+        const { providerService } = this;
+        if (!providerService) {
+            throw new Error("ExecutionService.executeTransactionPlan requires a providerService. Pass it to the ExecutionService constructor or call setProviderService().");
+        }
+        const helperArgs = {
+            ...args,
+            executionService: this,
+            deploymentService: this.deploymentService,
+            providerService,
+        };
+        return executeTransactionPlan(helperArgs);
+    }
+    getSimulationContext() {
+        return {
+            deploymentService: this.deploymentService,
+            walletService: this.walletService,
+            providerService: this.providerService,
+            vaultMetaService: this.vaultMetaService,
+            priceService: this.priceService,
+            rewardsService: this.rewardsService,
+            intrinsicApyService: this.intrinsicApyService,
+            eulerLabelsService: this.eulerLabelsService,
+            describeBatch: (batch) => this.describeBatch(batch),
+        };
+    }
+    getCoreAddresses(chainId) {
+        return this.deploymentService.getDeployment(chainId).addresses.coreAddrs;
+    }
     /**
      * Encodes an array of EVC batch items into a single calldata hex for `EVC.batch()`.
      *
@@ -30,11 +122,7 @@ export class ExecutionService {
      * @returns Encoded calldata hex for the EVC batch call
      */
     encodeBatch(items) {
-        return encodeFunctionData({
-            abi: ethereumVaultConnectorAbi,
-            functionName: "batch",
-            args: [items],
-        });
+        return encodeHelpers.encodeBatch(items);
     }
     /**
      * Encodes EVC batch items for depositing underlying assets into a vault (mints shares to receiver).
@@ -49,33 +137,9 @@ export class ExecutionService {
      * @param args.permit2 - Optional Permit2 message + signature; if set, prepends a permit2 permit call so transferFrom can be used
      * @returns Array of EVC batch items (optional permit2, optional enableCollateral, deposit)
      */
-    encodeDeposit({ chainId, vault, amount, receiver, owner, enableCollateral, permit2, }) {
-        const items = [];
-        if (permit2) {
-            const permit2Call = this.encodePermit2Call({
-                chainId,
-                owner,
-                message: permit2.message,
-                signature: permit2.signature,
-            });
-            items.push(permit2Call);
-        }
-        // Add enable collateral if flag is set
-        if (enableCollateral) {
-            items.push(this.encodeEnableCollateral(chainId, receiver, vault));
-        }
-        // Add deposit operation
-        items.push({
-            targetContract: vault,
-            onBehalfOfAccount: owner,
-            value: 0n,
-            data: encodeFunctionData({
-                abi: eVaultAbi,
-                functionName: "deposit",
-                args: [amount, receiver],
-            }),
-        });
-        return items;
+    encodeDeposit({ chainId, ...args }) {
+        const { evc, permit2 } = this.getCoreAddresses(chainId);
+        return encodeHelpers.encodeDeposit(evc, permit2, { chainId, ...args });
     }
     /**
      * Encodes EVC batch items for minting vault shares by depositing underlying assets.
@@ -90,33 +154,9 @@ export class ExecutionService {
      * @param args.permit2 - Optional Permit2 message + signature for transferFrom
      * @returns Array of EVC batch items (optional permit2, optional enableCollateral, mint)
      */
-    encodeMint({ chainId, vault, shares, receiver, owner, enableCollateral, permit2, }) {
-        const items = [];
-        if (permit2) {
-            const permit2Call = this.encodePermit2Call({
-                chainId,
-                owner,
-                message: permit2.message,
-                signature: permit2.signature,
-            });
-            items.push(permit2Call);
-        }
-        // Add enable collateral if flag is set
-        if (enableCollateral) {
-            items.push(this.encodeEnableCollateral(chainId, receiver, vault));
-        }
-        // Add mint operation
-        items.push({
-            targetContract: vault,
-            onBehalfOfAccount: owner,
-            value: 0n,
-            data: encodeFunctionData({
-                abi: eVaultAbi,
-                functionName: "mint",
-                args: [shares, receiver],
-            }),
-        });
-        return items;
+    encodeMint({ chainId, ...args }) {
+        const { evc, permit2 } = this.getCoreAddresses(chainId);
+        return encodeHelpers.encodeMint(evc, permit2, { chainId, ...args });
     }
     /**
      * Encodes EVC batch items for withdrawing underlying assets from a vault (burns shares).
@@ -130,24 +170,9 @@ export class ExecutionService {
      * @param args.disableCollateral - If true, appends disableCollateral( owner, vault ) via EVC before withdraw
      * @returns Array of EVC batch items (optional disableCollateral, withdraw)
      */
-    encodeWithdraw({ chainId, vault, assets, receiver, owner, disableCollateral, }) {
-        const items = [];
-        // Add disable collateral if flag is set
-        if (disableCollateral) {
-            items.push(this.encodeDisableCollateral(chainId, owner, vault));
-        }
-        // Add withdraw operation
-        items.push({
-            targetContract: vault,
-            onBehalfOfAccount: owner,
-            value: 0n,
-            data: encodeFunctionData({
-                abi: eVaultAbi,
-                functionName: "withdraw",
-                args: [assets, receiver, owner],
-            }),
-        });
-        return items;
+    encodeWithdraw({ chainId, ...args }) {
+        const { evc } = this.getCoreAddresses(chainId);
+        return encodeHelpers.encodeWithdraw(evc, { chainId, ...args });
     }
     /**
      * Encodes EVC batch items for redeeming vault shares for underlying assets.
@@ -161,24 +186,9 @@ export class ExecutionService {
      * @param args.disableCollateral - If true, prepends disableCollateral( owner, vault ) via EVC
      * @returns Array of EVC batch items (optional disableCollateral, redeem)
      */
-    encodeRedeem({ chainId, vault, shares, receiver, owner, disableCollateral, }) {
-        const items = [];
-        // Add disable collateral if flag is set
-        if (disableCollateral) {
-            items.push(this.encodeDisableCollateral(chainId, owner, vault));
-        }
-        // Add redeem operation
-        items.push({
-            targetContract: vault,
-            onBehalfOfAccount: owner,
-            value: 0n,
-            data: encodeFunctionData({
-                abi: eVaultAbi,
-                functionName: "redeem",
-                args: [shares, receiver, owner],
-            }),
-        });
-        return items;
+    encodeRedeem({ chainId, ...args }) {
+        const { evc } = this.getCoreAddresses(chainId);
+        return encodeHelpers.encodeRedeem(evc, { chainId, ...args });
     }
     /**
      * Encodes EVC batch items for borrowing from a liability vault, optionally depositing collateral in the same batch.
@@ -199,42 +209,8 @@ export class ExecutionService {
      * @returns Array of EVC batch items (optional deposit, optional disableController, optional enableController, borrow)
      */
     encodeBorrow(args) {
-        const { chainId, vault, amount, owner, borrowAccount, receiver, enableController = true, currentController, collateralVault, collateralAmount, enableCollateral = true, collateralPermit2, } = args;
-        const items = [];
-        // Add collateral if provided
-        if (collateralVault &&
-            collateralAmount !== undefined &&
-            collateralAmount > 0n) {
-            const depositItems = this.encodeDeposit({
-                chainId,
-                vault: collateralVault,
-                amount: collateralAmount,
-                receiver: borrowAccount,
-                enableCollateral,
-                permit2: collateralPermit2,
-                owner: owner,
-            });
-            items.push(...depositItems);
-        }
-        // Add disable controller if there's a different controller enabled
-        if (currentController && currentController !== vault) {
-            items.push(this.encodeDisableController(currentController, borrowAccount));
-        }
-        if (enableController) {
-            items.push(this.encodeEnableController(chainId, borrowAccount, vault));
-        }
-        // Add borrow operation
-        items.push({
-            targetContract: vault,
-            onBehalfOfAccount: borrowAccount,
-            value: 0n,
-            data: encodeFunctionData({
-                abi: eVaultAbi,
-                functionName: "borrow",
-                args: [amount, receiver],
-            }),
-        });
-        return items;
+        const { evc, permit2 } = this.getCoreAddresses(args.chainId);
+        return encodeHelpers.encodeBorrow(evc, permit2, args);
     }
     /**
      * Encodes EVC batch items for liquidating an undercollateralized account (repay debt, seize collateral).
@@ -251,28 +227,9 @@ export class ExecutionService {
      * @param args.enableCollateral - If true, enables collateral vault for liquidator sub-account after liquidate (default true)
      * @returns Array of EVC batch items (optional enableController, liquidate, optional enableCollateral)
      */
-    encodeLiquidation({ chainId, vault, violator, collateral, repayAssets, minYieldBalance, liquidatorSubAccountAddress, enableCollateral = true, enableController = true, }) {
-        const items = [];
-        // Optionally enable controller for the liquidator account on the liability vault
-        if (enableController) {
-            items.push(this.encodeEnableController(chainId, liquidatorSubAccountAddress, vault));
-        }
-        // Perform the liquidation
-        items.push({
-            targetContract: vault,
-            onBehalfOfAccount: liquidatorSubAccountAddress,
-            value: 0n,
-            data: encodeFunctionData({
-                abi: eVaultAbi,
-                functionName: "liquidate",
-                args: [violator, collateral, repayAssets, minYieldBalance],
-            }),
-        });
-        // Optionally enable collateral for the seized collateral vault on the liquidator account
-        if (enableCollateral) {
-            items.push(this.encodeEnableCollateral(chainId, liquidatorSubAccountAddress, collateral));
-        }
-        return items;
+    encodeLiquidation({ chainId, ...args }) {
+        const { evc } = this.getCoreAddresses(chainId);
+        return encodeHelpers.encodeLiquidation(evc, { chainId, ...args });
     }
     /**
      * Encodes EVC batch items for pulling debt from one sub-account to another on the same liability vault.
@@ -286,24 +243,9 @@ export class ExecutionService {
      * @param args.enableController - If true, enables vault as controller for `to` via EVC before pullDebt (default true)
      * @returns Array of EVC batch items (optional enableController, pullDebt)
      */
-    encodePullDebt({ chainId, vault, amount, from, to, enableController = true, }) {
-        const items = [];
-        // Add enable controller if flag is set
-        if (enableController) {
-            items.push(this.encodeEnableController(chainId, to, vault));
-        }
-        // Add pullDebt operation
-        items.push({
-            targetContract: vault,
-            onBehalfOfAccount: to,
-            value: 0n,
-            data: encodeFunctionData({
-                abi: eVaultAbi,
-                functionName: "pullDebt",
-                args: [amount, from],
-            }),
-        });
-        return items;
+    encodePullDebt({ chainId, ...args }) {
+        const { evc } = this.getCoreAddresses(chainId);
+        return encodeHelpers.encodePullDebt(evc, { chainId, ...args });
     }
     /**
      * Encodes EVC batch items for a multiply/leverage operation when liability and long asset differ (swap required).
@@ -327,77 +269,8 @@ export class ExecutionService {
      * @returns Array of EVC batch items
      */
     encodeMultiplyWithSwap(args) {
-        const { chainId, collateralVault, collateralAmount, liabilityVault, liabilityAmount, longVault, owner, receiver, enableCollateral = true, enableCollateralLong = true, currentController, enableController = true, collateralPermit2, swapQuote, } = args;
-        const items = [];
-        // 1. Add permit2 for collateral if provided
-        if (collateralPermit2) {
-            const permit2Call = this.encodePermit2Call({
-                chainId,
-                owner,
-                message: collateralPermit2.message,
-                signature: collateralPermit2.signature,
-            });
-            items.push(permit2Call);
-        }
-        // 2. Deposit initial collateral if amount > 0
-        if (collateralAmount > 0n) {
-            // Enable collateral for collateral vault
-            if (enableCollateral) {
-                items.push(this.encodeEnableCollateral(chainId, receiver, collateralVault));
-            }
-            // Deposit collateral
-            items.push({
-                targetContract: collateralVault,
-                onBehalfOfAccount: owner,
-                value: 0n,
-                data: encodeFunctionData({
-                    abi: eVaultAbi,
-                    functionName: "deposit",
-                    args: [collateralAmount, receiver],
-                }),
-            });
-        }
-        // 3. Disable current controller if there's a different one enabled
-        if (currentController && currentController !== liabilityVault) {
-            items.push(this.encodeDisableController(currentController, receiver));
-        }
-        // 4. Enable controller for liability vault
-        if (enableController) {
-            items.push(this.encodeEnableController(chainId, receiver, liabilityVault));
-        }
-        // 5. Borrow from liability vault to swapper
-        items.push({
-            targetContract: liabilityVault,
-            onBehalfOfAccount: receiver,
-            value: 0n,
-            data: encodeFunctionData({
-                abi: eVaultAbi,
-                functionName: "borrow",
-                args: [liabilityAmount, swapQuote.swap.swapperAddress],
-            }),
-        });
-        // 6. Execute swap multicall
-        items.push({
-            targetContract: swapQuote.swap.swapperAddress,
-            onBehalfOfAccount: receiver,
-            value: 0n,
-            data: swapQuote.swap.swapperData,
-        });
-        // 7. Verify swap and skim to long vault
-        if (swapQuote.verify.type !== "skimMin") {
-            throw new Error("Invalid swap quote type for multiply - must be skimMin");
-        }
-        items.push({
-            targetContract: swapQuote.verify.verifierAddress,
-            onBehalfOfAccount: receiver,
-            value: 0n,
-            data: swapQuote.verify.verifierData,
-        });
-        // 8. Enable collateral on long vault
-        if (enableCollateralLong && collateralVault !== longVault) {
-            items.push(this.encodeEnableCollateral(chainId, receiver, longVault));
-        }
-        return items;
+        const { evc, permit2 } = this.getCoreAddresses(args.chainId);
+        return encodeHelpers.encodeMultiplyWithSwap(evc, permit2, args);
     }
     /**
      * Encodes EVC batch items for a multiply/leverage operation when liability and long asset are the same (no swap).
@@ -420,71 +293,8 @@ export class ExecutionService {
      * @returns Array of EVC batch items
      */
     encodeMultiplySameAsset(args) {
-        const { chainId, collateralVault, collateralAmount, liabilityVault, liabilityAmount, longVault, owner, receiver, enableCollateral = true, enableCollateralLong = true, enableController = true, currentController, collateralPermit2, } = args;
-        const items = [];
-        // 1. Add permit2 for collateral if provided
-        if (collateralPermit2) {
-            const permit2Call = this.encodePermit2Call({
-                chainId,
-                owner,
-                message: collateralPermit2.message,
-                signature: collateralPermit2.signature,
-            });
-            items.push(permit2Call);
-        }
-        // 2. Deposit initial collateral if amount > 0
-        if (collateralAmount > 0n) {
-            // Enable collateral for collateral vault
-            if (enableCollateral) {
-                items.push(this.encodeEnableCollateral(chainId, receiver, collateralVault));
-            }
-            // Deposit collateral
-            items.push({
-                targetContract: collateralVault,
-                onBehalfOfAccount: owner,
-                value: 0n,
-                data: encodeFunctionData({
-                    abi: eVaultAbi,
-                    functionName: "deposit",
-                    args: [collateralAmount, receiver],
-                }),
-            });
-        }
-        // 3. Disable current controller if there's a different one enabled
-        if (currentController && currentController !== liabilityVault) {
-            items.push(this.encodeDisableController(currentController, receiver));
-        }
-        // 4. Enable controller for liability vault
-        if (enableController) {
-            items.push(this.encodeEnableController(chainId, receiver, liabilityVault));
-        }
-        // 5. Borrow from liability vault directly to long vault
-        items.push({
-            targetContract: liabilityVault,
-            onBehalfOfAccount: receiver,
-            value: 0n,
-            data: encodeFunctionData({
-                abi: eVaultAbi,
-                functionName: "borrow",
-                args: [liabilityAmount, longVault],
-            }),
-        });
-        // 6. Skim borrowed assets to position
-        items.push({
-            targetContract: longVault,
-            onBehalfOfAccount: receiver,
-            value: 0n,
-            data: encodeFunctionData({
-                abi: eVaultAbi,
-                functionName: "skim",
-                args: [liabilityAmount, receiver],
-            }),
-        });
-        // 7. Enable collateral on long vault
-        if (enableCollateralLong) {
-            items.push(this.encodeEnableCollateral(chainId, receiver, longVault));
-        }
-        return items;
+        const { evc, permit2 } = this.getCoreAddresses(args.chainId);
+        return encodeHelpers.encodeMultiplySameAsset(evc, permit2, args);
     }
     /**
      * Encodes EVC batch items for repaying debt using assets from the sender's wallet (transferFrom to vault then repay).
@@ -501,41 +311,16 @@ export class ExecutionService {
      * @returns Array of EVC batch items (optional permit2, repay, optional disableController)
      */
     encodeRepayFromWallet(args) {
-        const { chainId, sender, liabilityVault, liabilityAmount, receiver, disableControllerOnMax = true, isMax = false, permit2, } = args;
-        const items = [];
-        if (permit2) {
-            const permit2Call = this.encodePermit2Call({
-                chainId,
-                owner: sender,
-                message: permit2.message,
-                signature: permit2.signature,
-            });
-            items.push(permit2Call);
-        }
-        // Repay operation
-        items.push({
-            targetContract: liabilityVault,
-            onBehalfOfAccount: sender,
-            value: 0n,
-            data: encodeFunctionData({
-                abi: eVaultAbi,
-                functionName: "repay",
-                args: [isMax ? maxUint256 : liabilityAmount, receiver],
-            }),
-        });
-        // Disable controller if needed (for max repay)
-        // Sender must be allowed to act on behalf of receiver (sender is subaccount of receiver or is an operator)
-        if (disableControllerOnMax && isMax) {
-            items.push(this.encodeDisableController(liabilityVault, receiver));
-        }
-        return items;
+        const { permit2 } = this.getCoreAddresses(args.chainId);
+        return encodeHelpers.encodeRepayFromWallet(permit2, args);
     }
     /**
      * Encodes EVC batch items for repaying debt from a deposit (same-asset only).
-     * Path 1: same asset and same vault → repayWithShares. Path 2: same asset, different vault → withdraw then repay/skim/repayWithShares as needed.
+     * Path 1: same asset and same vault → repayWithShares.
+     * Path 2: same asset, different vault → withdraw to liability vault, skim, then repayWithShares.
      *
      * @param args - Repay-from-deposit encoding arguments
-     * @param args.chainId - Chain ID (used for EVC and optional permit2)
+     * @param args.chainId - Chain ID used for EVC controller calls
      * @param args.liabilityVault - Vault (liability) to repay debt to
      * @param args.liabilityAsset - Underlying asset address of the liability vault
      * @param args.liabilityAmount - Amount of liability to repay (maxUint256 with isMax for full repay)
@@ -545,37 +330,10 @@ export class ExecutionService {
      * @param args.fromAsset - Underlying asset of fromVault (must equal liabilityAsset)
      * @param args.disableControllerOnMax - When isMax, whether to disable controller for receiver (default true)
      * @param args.isMax - If true, repays full debt (amount used for withdraw sizing where applicable)
-     * @param args.liabilityPermit2 - Optional Permit2 for liability asset when path uses transfer/repay
      * @returns Array of EVC batch items. Throws if fromAsset !== liabilityAsset.
      */
     encodeRepayFromDeposit(args) {
-        const { chainId, liabilityVault, liabilityAsset, liabilityAmount, from, receiver, fromVault, fromAsset, disableControllerOnMax = true, isMax = false, liabilityPermit2, } = args;
-        // PATH 1: Same asset, same vault - use repayWithShares
-        if (fromAsset === liabilityAsset && fromVault === liabilityVault) {
-            return this.encodeRepayWithSharesSameAssetAndVault({
-                chainId,
-                vault: liabilityVault,
-                amount: liabilityAmount,
-                receiver,
-                from,
-                disableController: isMax && disableControllerOnMax,
-            });
-        }
-        // PATH 2: Same asset, different vault
-        if (fromAsset === liabilityAsset) {
-            return this.encodeRepayWithSharesSameAssetDifferentVault({
-                chainId,
-                fromVault,
-                toVault: liabilityVault,
-                amount: liabilityAmount,
-                receiver,
-                from,
-                isMax,
-                disableControllerOnMax,
-                permit2: liabilityPermit2,
-            });
-        }
-        throw new Error("encodeRepayFromDeposit only supports same-asset paths");
+        return encodeHelpers.encodeRepayFromDeposit(args);
     }
     /**
      * Encodes EVC batch items for repaying debt by swapping collateral (withdraw from vaultIn → swap → verify/repay debtMax).
@@ -590,50 +348,7 @@ export class ExecutionService {
      * @returns Array of EVC batch items (withdraw, swap, verify/repay, optional disableController)
      */
     encodeRepayWithSwap(args) {
-        const { swapQuote, maxWithdraw, isMax = false, disableControllerOnMax = true, } = args;
-        const items = [];
-        // Determine withdraw amount (cap to available amount if provided)
-        const withdrawAmount = maxWithdraw &&
-            maxWithdraw < BigInt(swapQuote.amountInMax || swapQuote.amountIn)
-            ? maxWithdraw
-            : BigInt(swapQuote.amountInMax || swapQuote.amountIn);
-        // 1. Withdraw collateral from vault to swapper
-        items.push({
-            targetContract: swapQuote.vaultIn,
-            onBehalfOfAccount: swapQuote.accountIn,
-            value: 0n,
-            data: encodeFunctionData({
-                abi: eVaultAbi,
-                functionName: "withdraw",
-                args: [
-                    withdrawAmount,
-                    swapQuote.swap.swapperAddress,
-                    swapQuote.accountIn,
-                ],
-            }),
-        });
-        // 2. Execute swap multicall
-        items.push({
-            targetContract: swapQuote.swap.swapperAddress,
-            onBehalfOfAccount: swapQuote.accountIn,
-            value: 0n,
-            data: swapQuote.swap.swapperData,
-        });
-        // 3. Verify swap and repay (verifyDebtMax handles the repay)
-        if (swapQuote.verify.type !== "debtMax") {
-            throw new Error("Invalid swap quote type for repay - must be debtMax");
-        }
-        items.push({
-            targetContract: swapQuote.verify.verifierAddress,
-            onBehalfOfAccount: swapQuote.verify.account,
-            value: 0n,
-            data: swapQuote.verify.verifierData,
-        });
-        // 4. Disable controller if needed (for max repay)
-        if (isMax && disableControllerOnMax) {
-            items.push(this.encodeDisableController(swapQuote.receiver, swapQuote.accountOut));
-        }
-        return items;
+        return encodeHelpers.encodeRepayWithSwap(args);
     }
     /**
      * Encodes EVC batch items for depositing into a vault using tokens from the user's wallet, going through a swap.
@@ -648,42 +363,24 @@ export class ExecutionService {
      * @returns Array of EVC batch items (transferFromSender, swap, verify, optional enableCollateral)
      */
     encodeDepositWithSwapFromWallet(args) {
-        const { chainId, swapQuote, amount, sender, enableCollateral = true, } = args;
-        const items = [];
-        // 1. Transfer tokens from sender's wallet to swapper via SwapVerifier.transferFromSender
-        items.push({
-            targetContract: swapQuote.verify.verifierAddress,
-            onBehalfOfAccount: sender,
-            value: 0n,
-            data: encodeFunctionData({
-                abi: swapVerifierAbi,
-                functionName: "transferFromSender",
-                args: [
-                    swapQuote.tokenIn.address,
-                    amount,
-                    swapQuote.swap.swapperAddress,
-                ],
-            }),
-        });
-        // 2. Execute swap multicall
-        items.push({
-            targetContract: swapQuote.swap.swapperAddress,
-            onBehalfOfAccount: sender,
-            value: 0n,
-            data: swapQuote.swap.swapperData,
-        });
-        // 3. Verify swap
-        items.push({
-            targetContract: swapQuote.verify.verifierAddress,
-            onBehalfOfAccount: swapQuote.accountOut || sender,
-            value: 0n,
-            data: swapQuote.verify.verifierData,
-        });
-        // 4. Enable collateral if needed
-        if (enableCollateral && swapQuote.receiver) {
-            items.push(this.encodeEnableCollateral(chainId, swapQuote.accountOut || sender, swapQuote.receiver));
-        }
-        return items;
+        const { evc } = this.getCoreAddresses(args.chainId);
+        return encodeHelpers.encodeDepositWithSwapFromWallet(evc, args);
+    }
+    /**
+     * Encodes EVC batch items for swapping a token from the sender's wallet into another token
+     * and transferring the output to `swapQuote.receiver`.
+     * The approval is given to SwapVerifier, then transferFromSender pulls tokens to Swapper,
+     * swap executes, and verifyAmountMinAndTransfer sends the output to the receiver wallet.
+     *
+     * @param args - Wallet-swap encoding arguments
+     * @param args.chainId - Chain ID (unused, kept for encode API symmetry)
+     * @param args.swapQuote - Quote with swap and verify steps (verify type transferMin)
+     * @param args.amount - Amount of input token to transfer from wallet to swapper
+     * @param args.sender - Wallet address providing the tokens (onBehalfOfAccount for transferFromSender)
+     * @returns Array of EVC batch items (transferFromSender, swap, verify)
+     */
+    encodeSwapFromWallet(args) {
+        return encodeHelpers.encodeSwapFromWallet(args);
     }
     /**
      * Encodes EVC batch items for swapping collateral: withdraw from vaultIn → swap → verify/skim to receiver; optional enable/disable collateral.
@@ -698,50 +395,8 @@ export class ExecutionService {
      * @returns Array of EVC batch items (withdraw, swap, verify/skim, optional disableCollateral, optional enableCollateral)
      */
     encodeSwapCollateral(args) {
-        const { chainId, swapQuote, enableCollateral = true, disableCollateralOnMax = true, isMax = false, } = args;
-        const items = [];
-        // 1. Withdraw from source vault to swapper
-        const withdrawAmount = BigInt(swapQuote.amountInMax || swapQuote.amountIn);
-        items.push({
-            targetContract: swapQuote.vaultIn,
-            onBehalfOfAccount: swapQuote.accountIn,
-            value: 0n,
-            data: encodeFunctionData({
-                abi: eVaultAbi,
-                functionName: "withdraw",
-                args: [
-                    withdrawAmount,
-                    swapQuote.swap.swapperAddress,
-                    swapQuote.accountIn,
-                ],
-            }),
-        });
-        // 2. Execute swap multicall
-        items.push({
-            targetContract: swapQuote.swap.swapperAddress,
-            onBehalfOfAccount: swapQuote.accountIn,
-            value: 0n,
-            data: swapQuote.swap.swapperData,
-        });
-        // 3. Verify swap and skim
-        if (swapQuote.verify.type !== "skimMin") {
-            throw new Error("Invalid swap quote type for swap collateral - must be skimMin");
-        }
-        items.push({
-            targetContract: swapQuote.verify.verifierAddress,
-            onBehalfOfAccount: swapQuote.accountOut,
-            value: 0n,
-            data: swapQuote.verify.verifierData,
-        });
-        // 4. Disable collateral if needed (for max swap)
-        if (isMax && disableCollateralOnMax) {
-            items.push(this.encodeDisableCollateral(chainId, swapQuote.accountIn, swapQuote.vaultIn));
-        }
-        // 5. Enable collateral if needed
-        if (enableCollateral) {
-            items.push(this.encodeEnableCollateral(chainId, swapQuote.accountOut, swapQuote.receiver));
-        }
-        return items;
+        const { evc } = this.getCoreAddresses(args.chainId);
+        return encodeHelpers.encodeSwapCollateral(evc, args);
     }
     /**
      * Encodes EVC batch items for swapping debt: enableController → borrow from vaultIn → swap → verify/repay (debtMax).
@@ -755,46 +410,51 @@ export class ExecutionService {
      * @param args.isMax - If true, treats as full debt swap (can trigger disableControllerOnMax)
      * @returns Array of EVC batch items (optional enableController, borrow, swap, verify/repay, optional disableController)
      */
-    encodeSwapDebt({ chainId, swapQuote, enableController = true, disableControllerOnMax = true, isMax = false, }) {
-        const items = [];
-        // Enable controller if needed
-        if (enableController) {
-            items.push(this.encodeEnableController(chainId, swapQuote.accountOut, swapQuote.vaultIn));
-        }
-        // Borrow from source vault
-        const borrowAmount = BigInt(swapQuote.amountInMax);
-        items.push({
-            targetContract: swapQuote.vaultIn,
-            onBehalfOfAccount: swapQuote.accountIn,
-            value: 0n,
-            data: encodeFunctionData({
-                abi: eVaultAbi,
-                functionName: "borrow",
-                args: [borrowAmount, swapQuote.swap.swapperAddress],
-            }),
-        });
-        // Execute swap multicall
-        items.push({
-            targetContract: swapQuote.swap.swapperAddress,
-            onBehalfOfAccount: swapQuote.accountIn,
-            value: 0n,
-            data: swapQuote.swap.swapperData,
-        });
-        // Verify swap and skim
-        if (swapQuote.verify.type !== "debtMax") {
-            throw new Error("Invalid swap quote type for repay - must be debtMax");
-        }
-        items.push({
-            targetContract: swapQuote.verify.verifierAddress,
-            onBehalfOfAccount: swapQuote.accountOut,
-            value: 0n,
-            data: swapQuote.verify.verifierData,
-        });
-        // Disable controller if needed (for max swap)
-        if (isMax && disableControllerOnMax) {
-            items.push(this.encodeDisableController(swapQuote.receiver, swapQuote.accountIn));
-        }
-        return items;
+    encodeSwapDebt(args) {
+        const { evc } = this.getCoreAddresses(args.chainId);
+        return encodeHelpers.encodeSwapDebt(evc, args);
+    }
+    /**
+     * Encodes EVC batch items for migrating a supplied/collateral position between two same-asset vaults.
+     * Partial migration uses withdraw(amount, toVault, account) then skim(amount, account).
+     * Max migration uses redeem(maxShares || maxUint256, toVault, account) then skim(amount, account).
+     *
+     * @param args - Same-asset collateral migration encoding arguments
+     * @param args.chainId - Chain ID (used for EVC enable/disable collateral)
+     * @param args.fromVault - Source vault holding the supplied shares
+     * @param args.toVault - Destination vault with the same underlying asset
+     * @param args.amount - Asset amount expected to arrive at the destination vault and be skimmed
+     * @param args.account - Sub-account that owns the source shares and receives destination shares
+     * @param args.isMax - If true, redeems shares instead of withdrawing assets
+     * @param args.maxShares - Optional exact share amount for max migration; defaults to maxUint256
+     * @param args.enableCollateralTo - If true, enables the destination vault as collateral after skim
+     * @param args.disableCollateralFrom - If true, disables the source vault as collateral after enabling the destination
+     * @returns Array of EVC batch items
+     */
+    encodeMigrateSameAssetCollateral(args) {
+        const { evc } = this.getCoreAddresses(args.chainId);
+        return encodeHelpers.encodeMigrateSameAssetCollateral(evc, args);
+    }
+    /**
+     * Encodes EVC batch items for migrating a full debt position between two same-asset liability vaults.
+     * Flow: enable new controller → borrow with interest cushion to old vault → skim → repay old debt with shares
+     * → disable old controller → optionally sweep cushion to the new vault → optionally transfer remaining new-vault shares.
+     *
+     * @param args - Same-asset debt migration encoding arguments
+     * @param args.chainId - Chain ID (used for EVC enable controller)
+     * @param args.oldLiabilityVault - Existing debt vault to fully repay and disable
+     * @param args.newLiabilityVault - New same-asset debt vault to borrow from
+     * @param args.amount - Current debt amount before applying the 0.01% interest cushion
+     * @param args.account - Sub-account that owns the debt position
+     * @param args.enableController - If true, enables the new liability vault as controller first
+     * @param args.disableController - If true, disables the old liability vault after repayment
+     * @param args.sweepExcess - If true, redeems any old-vault cushion shares back to the new vault and skims them
+     * @param args.transferRemainingSharesTo - If set, transfers all new-vault shares from the sub-account to this address
+     * @returns Array of EVC batch items
+     */
+    encodeMigrateSameAssetDebt(args) {
+        const { evc } = this.getCoreAddresses(args.chainId);
+        return encodeHelpers.encodeMigrateSameAssetDebt(evc, args);
     }
     /**
      * Encodes EVC batch items for transferring vault shares between sub-accounts.
@@ -809,28 +469,9 @@ export class ExecutionService {
      * @param args.disableCollateralFrom - If true, prepends disableCollateral( from, vault ) via EVC before transfer
      * @returns Array of EVC batch items (optional disableCollateralFrom, transfer, optional enableCollateralTo)
      */
-    encodeTransfer({ chainId, vault, to, amount, from, enableCollateralTo, disableCollateralFrom, }) {
-        const items = [];
-        // Add disable collateral from sender if flag is set
-        if (disableCollateralFrom) {
-            items.push(this.encodeDisableCollateral(chainId, from, vault));
-        }
-        // Add transfer operation
-        items.push({
-            targetContract: vault,
-            onBehalfOfAccount: from,
-            value: 0n,
-            data: encodeFunctionData({
-                abi: eVaultAbi,
-                functionName: "transfer",
-                args: [to, amount],
-            }),
-        });
-        // Add enable collateral to receiver if flag is set
-        if (enableCollateralTo) {
-            items.push(this.encodeEnableCollateral(chainId, to, vault));
-        }
-        return items;
+    encodeTransfer({ chainId, ...args }) {
+        const { evc } = this.getCoreAddresses(chainId);
+        return encodeHelpers.encodeTransfer(evc, { chainId, ...args });
     }
     /**
      * Encodes a single EVC batch item that calls Permit2's `permit` with the given message and signature.
@@ -844,73 +485,23 @@ export class ExecutionService {
      * @returns Single EVC batch item (targetContract = Permit2, permit call)
      */
     encodePermit2Call(args) {
-        const { chainId, owner, message, signature } = args;
-        const deployment = this.deploymentService.getDeployment(chainId);
-        const permit2 = deployment.addresses.coreAddrs.permit2;
-        return {
-            targetContract: permit2,
-            onBehalfOfAccount: owner,
-            value: 0n,
-            data: encodeFunctionData({
-                abi: permit2PermitAbi,
-                functionName: "permit",
-                args: [owner, message, signature],
-            }),
-        };
+        const { permit2 } = this.getCoreAddresses(args.chainId);
+        return encodeHelpers.encodePermit2Call(permit2, args);
     }
     encodeEnableCollateral(chainId, account, vault) {
-        const deployment = this.deploymentService.getDeployment(chainId);
-        const evc = deployment.addresses.coreAddrs.evc;
-        return {
-            targetContract: evc,
-            onBehalfOfAccount: zeroAddress,
-            value: 0n,
-            data: encodeFunctionData({
-                abi: ethereumVaultConnectorAbi,
-                functionName: "enableCollateral",
-                args: [account, vault],
-            }),
-        };
+        const { evc } = this.getCoreAddresses(chainId);
+        return encodeHelpers.encodeEnableCollateral(evc, account, vault);
     }
     encodeDisableCollateral(chainId, account, vault) {
-        const deployment = this.deploymentService.getDeployment(chainId);
-        const evc = deployment.addresses.coreAddrs.evc;
-        return {
-            targetContract: evc,
-            onBehalfOfAccount: zeroAddress,
-            value: 0n,
-            data: encodeFunctionData({
-                abi: ethereumVaultConnectorAbi,
-                functionName: "disableCollateral",
-                args: [account, vault],
-            }),
-        };
+        const { evc } = this.getCoreAddresses(chainId);
+        return encodeHelpers.encodeDisableCollateral(evc, account, vault);
     }
     encodeEnableController(chainId, account, vault) {
-        const deployment = this.deploymentService.getDeployment(chainId);
-        const evc = deployment.addresses.coreAddrs.evc;
-        return {
-            targetContract: evc,
-            onBehalfOfAccount: zeroAddress,
-            value: 0n,
-            data: encodeFunctionData({
-                abi: ethereumVaultConnectorAbi,
-                functionName: "enableController",
-                args: [account, vault],
-            }),
-        };
+        const { evc } = this.getCoreAddresses(chainId);
+        return encodeHelpers.encodeEnableController(evc, account, vault);
     }
     encodeDisableController(vault, account) {
-        return {
-            targetContract: vault,
-            onBehalfOfAccount: account,
-            value: 0n,
-            data: encodeFunctionData({
-                abi: eVaultAbi,
-                functionName: "disableController",
-                args: [],
-            }),
-        };
+        return encodeHelpers.encodeDisableController(vault, account);
     }
     /**
      * Builds EIP-712 typed data for a Permit2 PermitSingle signature (token approval for a spender).
@@ -927,46 +518,10 @@ export class ExecutionService {
      * @returns EIP-712 typed data (domain, types, primaryType, message) for signing
      */
     getPermit2TypedData(args) {
-        const nowInSeconds = () => BigInt(Math.floor(Date.now() / 1000));
-        const { chainId, token, amount, spender, nonce, sigDeadline, expiration } = args;
-        const deployment = this.deploymentService.getDeployment(chainId);
-        const permit2 = deployment.addresses.coreAddrs.permit2;
-        const permitSingle = {
-            details: {
-                token,
-                amount: amount > maxUint160 ? maxUint160 : amount,
-                expiration: expiration ?? Number(maxUint48),
-                nonce,
-            },
-            spender,
-            sigDeadline: sigDeadline ?? nowInSeconds() + PERMIT2_SIG_WINDOW,
-        };
-        return {
-            domain: {
-                name: "Permit2",
-                chainId,
-                verifyingContract: permit2,
-            },
-            types: PERMIT2_TYPES,
-            primaryType: "PermitSingle",
-            message: permitSingle,
-        };
+        const { permit2 } = this.getCoreAddresses(args.chainId);
+        return encodeHelpers.getPermit2TypedData(permit2, args);
     }
-    /**
-     * Decodes EVC batch items into human-readable function names and named arguments.
-     * Tries known ABIs (EVC, eVault, Permit2, swapper, swapVerifier) to decode each item's data.
-     *
-     * @param batch - Array of EVC batch items (targetContract, onBehalfOfAccount, value, data) to decode
-     * @param extraAbis - Optional extra ABIs to try first when decoding unknown batch items.
-     * @returns Array of decoded items with targetContract, onBehalfOfAccount, functionName, and args (record of param name to value). Throws if any item cannot be decoded.
-     * @example
-     * const batchItems = executionService.encodeDeposit({ ... });
-     * const described = executionService.describeBatch(batchItems);
-     * console.log(described[0].functionName); // "deposit"
-     * console.log(described[0].args); // { amount: 1000n, receiver: "0x..." }
-     */
     describeBatch(batch, extraAbis) {
-        const decodedBatchItems = [];
         const executionDecodeAbis = [
             ...(extraAbis ?? []),
             ethereumVaultConnectorAbi,
@@ -975,7 +530,7 @@ export class ExecutionService {
             swapperAbi,
             swapVerifierAbi,
         ];
-        for (const item of batch) {
+        const decodeBatchItem = (item) => {
             let decoded = false;
             for (const abi of executionDecodeAbis) {
                 try {
@@ -1000,14 +555,13 @@ export class ExecutionService {
                             }
                         });
                     }
-                    decodedBatchItems.push({
+                    decoded = true;
+                    return {
                         targetContract: item.targetContract,
                         onBehalfOfAccount: item.onBehalfOfAccount,
                         functionName: decodedData.functionName,
                         args: namedArgs,
-                    });
-                    decoded = true;
-                    break;
+                    };
                 }
                 catch { }
             }
@@ -1019,29 +573,35 @@ export class ExecutionService {
                     try {
                         const result = plugin.decodeBatchItem(item);
                         if (result) {
-                            decodedBatchItems.push(result);
                             decoded = true;
-                            break;
+                            return result;
                         }
                     }
                     catch { }
                 }
             }
             if (!decoded) {
-                decodedBatchItems.push({
+                return {
                     targetContract: item.targetContract,
                     onBehalfOfAccount: item.onBehalfOfAccount,
                     functionName: "Unknown",
                     args: {},
-                });
+                };
             }
-        }
-        return decodedBatchItems;
+            throw new Error("unreachable batch item decode state");
+        };
+        return batch.map((entry) => isEVCBatchOperation(entry)
+            ? {
+                type: "operation",
+                name: entry.name,
+                items: entry.items.map(decodeBatchItem),
+            }
+            : decodeBatchItem(entry));
     }
     /**
      * Merges multiple transaction plans into a single plan.
      * Required approvals for the same (token, owner, spender) are summed.
-     * Executable items are preserved in order; adjacent EVC batch items are concatenated.
+     * Executable items are preserved in order; adjacent EVC batches are concatenated without flattening operation groupings.
      * Can be used to construct a transaction queue.
      *
      * @param plans - Array of transaction plans to merge
@@ -1067,19 +627,37 @@ export class ExecutionService {
                 else if (item.type === "evcBatch") {
                     const previous = executableItems[executableItems.length - 1];
                     if (previous?.type === "evcBatch") {
-                        previous.items.push(...item.items);
+                        previous.items.push(...cloneBatchEntries(item.items));
                     }
                     else {
-                        executableItems.push({ type: "evcBatch", items: [...item.items] });
+                        executableItems.push({
+                            type: "evcBatch",
+                            items: cloneBatchEntries(item.items),
+                        });
                     }
                 }
                 else {
-                    executableItems.push(item);
+                    throw new Error("ExecutionService.mergePlans cannot merge contractCall plan items. Merge these plans manually to preserve call boundaries.");
                 }
             }
         }
         return [...approvalByKey.values(), ...executableItems];
     }
+    /**
+     * Appends a raw batch item to the last EVC batch in the plan, or creates one.
+     * Mutates and returns the provided plan.
+     */
+    addBatchItemToPlan(plan, item) {
+        for (let index = plan.length - 1; index >= 0; index--) {
+            const planItem = plan[index];
+            if (planItem?.type === "evcBatch") {
+                planItem.items.push(item);
+                return plan;
+            }
+        }
+        plan.push({ type: "evcBatch", items: [item] });
+        return plan;
+    }
     /**
      * Converts EVC batch items into a transaction plan.
      * Returns a plan with a single evcBatch containing the given items (no required approvals).
@@ -1088,117 +666,50 @@ export class ExecutionService {
      * @param items - EVC batch items to wrap in a plan
      * @returns Transaction plan containing one evcBatch with the items
      */
-    convertBatchItemsToPlan(items) {
+    convertBatchItemsToPlan(items, operationName) {
         if (items.length === 0)
             return [];
+        if (operationName) {
+            return [
+                {
+                    type: "evcBatch",
+                    items: [{ type: "operation", name: operationName, items }],
+                },
+            ];
+        }
         return [{ type: "evcBatch", items }];
     }
-    /**
-     * Encodes batch items for repaying with shares from the same asset and vault
-     */
-    encodeRepayWithSharesSameAssetAndVault({ chainId: _chainId, vault, amount, from, receiver, disableController, }) {
-        const items = [];
-        // Repay with shares
-        items.push({
-            targetContract: vault,
-            onBehalfOfAccount: from,
-            value: 0n,
-            data: encodeFunctionData({
-                abi: eVaultAbi,
-                functionName: "repayWithShares",
-                args: [amount, receiver],
-            }),
-        });
-        // Disable controller if needed (for max repay)
-        if (disableController) {
-            items.push(this.encodeDisableController(vault, receiver));
-        }
-        return items;
+    encodeTransferFromMax(vault, from, to) {
+        return encodeHelpers.encodeTransferFromMax(vault, from, to);
     }
     /**
-     * Encodes batch items for repaying with shares from same asset but different vault
+     * Appends post-full-repay cleanup calls owned by plan builders:
+     * disable each active collateral used by the repaid borrow, transfer those collateral shares to the owner,
+     * and, when a source deposit funded the repay, transfer any remaining source-vault shares to the owner.
      */
-    encodeRepayWithSharesSameAssetDifferentVault({ chainId, fromVault, toVault, amount, // if isMax, this should be the total current debt
-    receiver, from, isMax, disableControllerOnMax, permit2, }) {
-        const items = [];
-        if (isMax) {
-            // if amount was max uint, skim and repay with shares would not revert if after withdraw funds were skimmed
-            // by other party
-            if (amount == maxUint256) {
-                throw new Error("Amount is maxUint256, cannot be used for max repay");
-            }
-            // For max repay: withdraw full debt amount +1 BPS to cover interest, then skim, then repayWithShares max
-            const amountWithExtra = (amount * 10001n) / 10000n;
-            if (amountWithExtra >= maxUint256) {
-                throw new Error("Amount with extra exceeds maxUint256");
-            }
-            // 1. Withdraw from collateral vault
-            items.push({
-                targetContract: fromVault,
-                onBehalfOfAccount: from,
-                value: 0n,
-                data: encodeFunctionData({
-                    abi: eVaultAbi,
-                    functionName: "withdraw",
-                    args: [amountWithExtra, toVault, from],
-                }),
-            });
-            // 2. Skim exact withdrawal amount to liability vault
-            items.push({
-                targetContract: toVault,
-                onBehalfOfAccount: from,
-                value: 0n,
-                data: encodeFunctionData({
-                    abi: eVaultAbi,
-                    functionName: "skim",
-                    args: [amountWithExtra, receiver],
-                }),
-            });
-            // 3. Repay with shares (max)
-            items.push({
-                targetContract: toVault,
-                onBehalfOfAccount: receiver,
-                value: 0n,
-                data: encodeFunctionData({
-                    abi: eVaultAbi,
-                    functionName: "repayWithShares",
-                    // max is ok now, because skim deposited exact amount and it is the full debt,
-                    // so pre-existing balance will not be consumed
-                    args: [maxUint256, receiver],
-                }),
-            });
-            // 4. Disable controller if needed
-            if (disableControllerOnMax) {
-                items.push(this.encodeDisableController(toVault, receiver));
+    appendMaxRepayCleanup(args) {
+        const { account, liabilityPosition, receiver, batchItems, sourceAccount, sourceVault, } = args;
+        const receiverSubAccount = typeof account.getSubAccount === "function"
+            ? account.getSubAccount(receiver)
+            : undefined;
+        const activeCollaterals = receiverSubAccount
+            ? resolveBorrowCollateralPositions(receiverSubAccount, liabilityPosition)
+            : [];
+        const transferredPositions = new Set();
+        for (const collateral of activeCollaterals) {
+            batchItems.push(this.encodeDisableCollateral(account.chainId, receiver, collateral.vaultAddress));
+            if (getAddress(receiver) !== getAddress(account.owner)) {
+                batchItems.push(this.encodeTransferFromMax(collateral.vaultAddress, receiver, account.owner));
             }
+            transferredPositions.add(`${getAddress(receiver)}:${getAddress(collateral.vaultAddress)}`);
         }
-        else {
-            // For partial repay: withdraw, then repay exact amount
-            // 1. Withdraw from collateral vault
-            items.push({
-                targetContract: fromVault,
-                onBehalfOfAccount: from,
-                value: 0n,
-                data: encodeFunctionData({
-                    abi: eVaultAbi,
-                    functionName: "withdraw",
-                    args: [amount, from, from],
-                }),
-            });
-            // 2. Repay exact amount
-            const repayItems = this.encodeRepayFromWallet({
-                chainId,
-                sender: from,
-                liabilityVault: toVault,
-                liabilityAmount: amount,
-                receiver,
-                disableControllerOnMax,
-                isMax,
-                permit2,
-            });
-            items.push(...repayItems);
+        if (sourceAccount && sourceVault) {
+            const sourcePositionKey = `${getAddress(sourceAccount)}:${getAddress(sourceVault)}`;
+            if (getAddress(sourceAccount) !== getAddress(account.owner) &&
+                !transferredPositions.has(sourcePositionKey)) {
+                batchItems.push(this.encodeTransferFromMax(sourceVault, sourceAccount, account.owner));
+            }
         }
-        return items;
     }
     /**
      * Resolves RequiredApproval items in a transaction plan by filling in each item's `resolved` field.
@@ -1237,6 +748,13 @@ export class ExecutionService {
                         args: [approvalSpender, approvalAmount],
                     }),
                 });
+                const addApproveWithOptionalReset = (approvalSpender, approvalAmount, currentAllowance) => {
+                    if (currentAllowance > 0n &&
+                        requiresZeroApprovalReset(chainId, token)) {
+                        resolvedItems.push(makeApprove(approvalSpender, 0n));
+                    }
+                    resolvedItems.push(makeApprove(approvalSpender, approvalAmount));
+                };
                 const makePermit2 = (permit2Spender, permit2Amount) => ({
                     type: "permit2",
                     token,
@@ -1275,7 +793,7 @@ export class ExecutionService {
                     }
                     // If assetForPermit2 is insufficient, we need both approval and permit2 signature
                     if (!hasSufficientPermit2Allowance) {
-                        resolvedItems.push(makeApprove(permit2, unlimitedApproval ? maxUint256 : amount));
+                        addApproveWithOptionalReset(permit2, unlimitedApproval ? maxUint256 : amount, assetForPermit2);
                         resolvedItems.push(makePermit2(spender, unlimitedApproval ? maxUint160 : amount));
                     }
                     else {
@@ -1293,7 +811,7 @@ export class ExecutionService {
                         approval.resolved = [];
                         continue;
                     }
-                    resolvedItems.push(makeApprove(spender, unlimitedApproval ? maxUint256 : amount));
+                    addApproveWithOptionalReset(spender, unlimitedApproval ? maxUint256 : amount, assetForVault);
                     approval.resolved = resolvedItems;
                 }
             }
@@ -1314,6 +832,9 @@ export class ExecutionService {
      */
     async resolveRequiredApprovals(args) {
         const { plan, chainId, account, usePermit2 = true, unlimitedApproval = false, } = args;
+        if (!this.walletService) {
+            throw new Error("ExecutionService.resolveRequiredApprovals requires a walletService. Pass it to the ExecutionService constructor or call setWalletService().");
+        }
         // Filter transaction plan for only RequiredApproval items
         const requiredApprovals = plan.filter((item) => item.type === "requiredApproval");
         // Transform RequiredApprovals into AssetWithSpenders
@@ -1378,10 +899,7 @@ export class ExecutionService {
             enableCollateral: !isCollateralEnabled && enableCollateral,
             // Permit2 is handled separately in the plan
         });
-        plan.push({
-            type: "evcBatch",
-            items: batchItems,
-        });
+        plan.push(...this.convertBatchItemsToPlan(batchItems, "deposit"));
         return plan;
     }
     /**
@@ -1423,10 +941,7 @@ export class ExecutionService {
             enableCollateral: !isCollateralEnabled && enableCollateral,
             // Permit2 is handled separately in the plan
         });
-        plan.push({
-            type: "evcBatch",
-            items: batchItems,
-        });
+        plan.push(...this.convertBatchItemsToPlan(batchItems, "mint"));
         return plan;
     }
     /**
@@ -1455,10 +970,7 @@ export class ExecutionService {
             owner,
             disableCollateral: disableCollateral && (!position || position.isCollateral),
         });
-        plan.push({
-            type: "evcBatch",
-            items: batchItems,
-        });
+        plan.push(...this.convertBatchItemsToPlan(batchItems, "withdraw"));
         return plan;
     }
     /**
@@ -1488,10 +1000,7 @@ export class ExecutionService {
             owner,
             disableCollateral: disableCollateral && (!position || position.isCollateral),
         });
-        plan.push({
-            type: "evcBatch",
-            items: batchItems,
-        });
+        plan.push(...this.convertBatchItemsToPlan(batchItems, "redeem"));
         return plan;
     }
     /**
@@ -1513,6 +1022,12 @@ export class ExecutionService {
     planBorrow(args) {
         const { vault, amount, receiver, borrowAccount, account, collateral } = args;
         const plan = [];
+        const savingsCollateral = isSavingsCollateral(collateral)
+            ? collateral
+            : undefined;
+        const walletCollateral = isWalletCollateral(collateral)
+            ? collateral
+            : undefined;
         const enableCollateral = collateral && collateral.amount > 0n
             ? !(account?.isCollateralEnabled(borrowAccount, collateral.vault) ??
                 false)
@@ -1521,15 +1036,15 @@ export class ExecutionService {
         // Default: controller is not enabled when account/sub-account is not available
         const currentController = account?.getCurrentController(borrowAccount);
         const enableController = !(account?.isControllerEnabled(borrowAccount, vault) ?? false);
-        if (collateral && collateral.amount > 0n) {
+        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)
             plan.push({
                 type: "requiredApproval",
-                token: collateral.asset,
+                token: walletCollateral.asset,
                 owner: account.owner,
-                spender: collateral.vault,
-                amount: collateral.amount,
+                spender: walletCollateral.vault,
+                amount: walletCollateral.amount,
             });
         }
         const batchItems = this.encodeBorrow({
@@ -1543,12 +1058,18 @@ export class ExecutionService {
             currentController: currentController || undefined,
             enableCollateral,
             collateralVault: collateral?.vault,
-            collateralAmount: collateral?.amount,
-        });
-        plan.push({
-            type: "evcBatch",
-            items: batchItems,
+            collateralAmount: walletCollateral?.amount,
+            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;
     }
     /**
@@ -1592,10 +1113,7 @@ export class ExecutionService {
             enableController,
             enableCollateral,
         });
-        plan.push({
-            type: "evcBatch",
-            items: batchItems,
-        });
+        plan.push(...this.convertBatchItemsToPlan(batchItems, "liquidation"));
         return plan;
     }
     /**
@@ -1607,10 +1125,11 @@ export class ExecutionService {
      * @param args.liabilityAmount - Amount of liability asset to repay (use maxUint256 for "repay all")
      * @param args.receiver - Sub-account address whose debt is being repaid
      * @param args.account - Account entity; used for chainId, owner, and position (to resolve liability asset)
+     * @param args.cleanupOnMax - When true and liabilityAmount is maxUint256, the batch disables active collaterals on the repaid sub-account and transfers their shares to the owner account (default false)
      * @returns Array of transaction plan items (approval + EVC batch)
      */
     planRepayFromWallet(args) {
-        const { liabilityVault, liabilityAmount, receiver, account } = args;
+        const { liabilityVault, liabilityAmount, receiver, account, cleanupOnMax = false, } = args;
         const plan = [];
         // Get position to determine asset
         const position = account?.getPosition(receiver, liabilityVault);
@@ -1625,6 +1144,7 @@ export class ExecutionService {
             spender: liabilityVault,
             amount: liabilityAmount,
         });
+        const isMax = liabilityAmount === maxUint256;
         // Build EVC batch items
         const batchItems = this.encodeRepayFromWallet({
             chainId: account.chainId,
@@ -1633,18 +1153,28 @@ export class ExecutionService {
             liabilityAmount,
             receiver,
             disableControllerOnMax: true,
-            isMax: liabilityAmount === maxUint256,
+            isMax,
             // Permit2 is handled separately in the plan
         });
-        plan.push({
-            type: "evcBatch",
-            items: batchItems,
-        });
+        if (cleanupOnMax && isMax) {
+            this.appendMaxRepayCleanup({
+                account,
+                liabilityPosition: position,
+                receiver,
+                batchItems,
+            });
+        }
+        plan.push(...this.convertBatchItemsToPlan(batchItems, "repayFromWallet"));
         return plan;
     }
     /**
      * Builds a transaction plan for repaying debt using assets from another vault deposit (same asset only).
-     * Use `maxUint256` for `liabilityAmount` to repay all available debt or up to the available deposit.
+     * Use `maxUint256` for `liabilityAmount` to perform a full repay.
+     * Full repay can opt into cleanup. For different-vault full repays, cleanup only redeems
+     * liability-vault shares left from the repay cushion when the account snapshot shows no pre-existing liability-vault deposit;
+     * otherwise those shares are preserved in the liability vault instead of being migrated to the source vault.
+     * Cleanup also disables active collaterals on the repaid sub-account, transfers those collateral shares to the owner
+     * account, and transfers any remaining source-vault shares from the source sub-account to the owner account.
      *
      * @param args - Repay-from-deposit plan arguments
      * @param args.liabilityVault - Address of the liability vault (debt is repaid to this vault)
@@ -1653,10 +1183,11 @@ export class ExecutionService {
      * @param args.fromVault - Vault to withdraw assets from (must be same underlying asset as liability for this plan)
      * @param args.fromAccount - Sub-account that holds the deposit in `fromVault`
      * @param args.account - Account entity; used for chainId, owner, and positions (to resolve assets and eligibility)
-     * @returns Array of transaction plan items (optional approval + EVC batch). Throws if asset differs between fromVault and liabilityVault; use planRepayWithSwap for cross-asset.
+     * @param args.cleanupOnMax - Whether max repay should append repay-cushion, collateral, and source-share cleanup (default false)
+     * @returns Array of transaction plan items (EVC batch only). Throws if asset differs between fromVault and liabilityVault; use planRepayWithSwap for cross-asset.
      */
     planRepayFromDeposit(args) {
-        const { liabilityVault, liabilityAmount, receiver, fromVault, fromAccount, account, } = args;
+        const { liabilityVault, liabilityAmount, receiver, fromVault, fromAccount, account, cleanupOnMax = false, } = args;
         const plan = [];
         // Get positions
         const liabilityPosition = account?.getPosition(receiver, liabilityVault);
@@ -1668,40 +1199,65 @@ export class ExecutionService {
         }
         const liabilityAsset = liabilityPosition.asset;
         const fromAsset = fromPosition.asset;
-        // Check if approval is needed (only if different assets and we need to swap/withdraw)
+        // Cross-asset repay requires a swap path; this planner only builds same-asset batches.
         if (fromAsset !== liabilityAsset) {
             // This path requires a swap, which is handled by planRepayWithSwap
             throw new Error("planRepayFromDeposit only supports same-asset paths. Use planRepayWithSwap for different assets.");
         }
-        // If same asset, different vault, we might need approval for the withdraw/repay path
-        if (fromVault !== liabilityVault) {
-            // Add approval requirement (will be resolved later with Wallet data)
-            plan.push({
-                type: "requiredApproval",
-                token: liabilityAsset,
-                owner: account.owner,
-                spender: liabilityVault,
-                amount: liabilityAmount,
-            });
-        }
+        const isMax = liabilityAmount === maxUint256;
+        const amount = isMax && fromVault !== liabilityVault
+            ? liabilityPosition.borrowed
+            : liabilityAmount;
+        const hasPreExistingLiabilityDeposit = (liabilityPosition.assets ?? 0n) > 0n;
         // Build EVC batch items
         const batchItems = this.encodeRepayFromDeposit({
             chainId: account.chainId,
             liabilityVault,
             liabilityAsset,
-            liabilityAmount,
-            from: receiver,
+            liabilityAmount: amount,
+            from: fromAccount,
             receiver,
             fromVault,
             fromAsset,
             disableControllerOnMax: true,
-            isMax: liabilityAmount === maxUint256,
+            isMax,
             // Permit2 is handled separately in the plan
         });
-        plan.push({
-            type: "evcBatch",
-            items: batchItems,
-        });
+        if (cleanupOnMax && isMax) {
+            if (fromVault !== liabilityVault && !hasPreExistingLiabilityDeposit) {
+                // Sweep only the repay cushion. If liability shares existed before this batch,
+                // redeem(max) would also migrate that unrelated deposit into the source vault.
+                batchItems.push({
+                    targetContract: liabilityVault,
+                    onBehalfOfAccount: receiver,
+                    value: 0n,
+                    data: encodeFunctionData({
+                        abi: eVaultAbi,
+                        functionName: "redeem",
+                        args: [maxUint256, fromVault, receiver],
+                    }),
+                });
+                batchItems.push({
+                    targetContract: fromVault,
+                    onBehalfOfAccount: fromAccount,
+                    value: 0n,
+                    data: encodeFunctionData({
+                        abi: eVaultAbi,
+                        functionName: "skim",
+                        args: [maxUint256, fromAccount],
+                    }),
+                });
+            }
+            this.appendMaxRepayCleanup({
+                account,
+                liabilityPosition,
+                receiver,
+                batchItems,
+                sourceAccount: fromAccount,
+                sourceVault: fromVault,
+            });
+        }
+        plan.push(...this.convertBatchItemsToPlan(batchItems, "repayFromDeposit"));
         return plan;
     }
     /**
@@ -1711,10 +1267,11 @@ export class ExecutionService {
      * @param args - Repay-with-swap plan arguments
      * @param args.swapQuote - Quote from swap service (e.g. fetchRepayQuotes); defines vaultIn, accountIn, accountOut, receiver, swap and verify steps
      * @param args.account - Account entity; used for chainId and positions (to compute isMax and maxWithdraw)
+     * @param args.cleanupOnMax - When true and the quote repays the full debt, the batch disables active collaterals on the repaid sub-account, transfers their shares to the owner account, and transfers remaining source-vault shares to the owner account (default false)
      * @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 } = args;
+        const { swapQuote, account, cleanupOnMax = false } = args;
         const plan = [];
         const liabilityPosition = account?.getPosition(swapQuote.accountOut, swapQuote.receiver);
         const fromPosition = account?.getPosition(swapQuote.accountIn, swapQuote.vaultIn);
@@ -1733,10 +1290,17 @@ export class ExecutionService {
             isMax,
             disableControllerOnMax: true,
         });
-        plan.push({
-            type: "evcBatch",
-            items: batchItems,
-        });
+        if (cleanupOnMax && isMax) {
+            this.appendMaxRepayCleanup({
+                account,
+                liabilityPosition,
+                receiver: swapQuote.accountOut,
+                batchItems,
+                sourceAccount: swapQuote.accountIn,
+                sourceVault: swapQuote.vaultIn,
+            });
+        }
+        plan.push(...this.convertBatchItemsToPlan(batchItems, "repayWithSwap"));
         return plan;
     }
     /**
@@ -1778,10 +1342,37 @@ export class ExecutionService {
             sender: account.owner,
             enableCollateral: shouldEnableCollateral,
         });
+        plan.push(...this.convertBatchItemsToPlan(batchItems, "depositWithSwapFromWallet"));
+        return plan;
+    }
+    /**
+     * Builds a transaction plan for swapping a token from the sender's wallet into another
+     * token and transferring the output to the quote receiver.
+     *
+     * @param args - Wallet-swap plan arguments
+     * @param args.swapQuote - Quote from swap service; must use transferOutputToReceiver / transferMin verification
+     * @param args.amount - Amount of input token to transfer from wallet
+     * @param args.tokenIn - Input token address (for approval to SwapVerifier)
+     * @param args.account - Account entity; used for chainId and owner
+     * @returns Array of transaction plan items (approval to SwapVerifier + EVC batch)
+     */
+    planSwapFromWallet(args) {
+        const { swapQuote, amount, tokenIn, account } = args;
+        const plan = [];
         plan.push({
-            type: "evcBatch",
-            items: batchItems,
+            type: "requiredApproval",
+            token: tokenIn,
+            owner: account.owner,
+            spender: swapQuote.verify.verifierAddress,
+            amount,
         });
+        const batchItems = this.encodeSwapFromWallet({
+            chainId: account.chainId,
+            swapQuote,
+            amount,
+            sender: account.owner,
+        });
+        plan.push(...this.convertBatchItemsToPlan(batchItems, "swapFromWallet"));
         return plan;
     }
     /**
@@ -1813,10 +1404,7 @@ export class ExecutionService {
             disableCollateralOnMax: true,
             isMax,
         });
-        plan.push({
-            type: "evcBatch",
-            items: batchItems,
-        });
+        plan.push(...this.convertBatchItemsToPlan(batchItems, "swapCollateral"));
         return plan;
     }
     /**
@@ -1844,10 +1432,103 @@ export class ExecutionService {
             disableControllerOnMax: true,
             isMax,
         });
-        plan.push({
-            type: "evcBatch",
-            items: batchItems,
+        plan.push(...this.convertBatchItemsToPlan(batchItems, "swapDebt"));
+        return plan;
+    }
+    /**
+     * Builds a transaction plan for migrating a supplied/collateral position between two same-asset vaults.
+     * This is the no-swap path for moving shares from one vault to another vault with the same underlying asset.
+     *
+     * @param args - Same-asset collateral migration plan arguments
+     * @param args.fromVault - Source vault holding the supplied shares
+     * @param args.toVault - Destination vault with the same underlying asset
+     * @param args.amount - Asset amount to withdraw/redeem and skim into the destination vault
+     * @param args.positionAccount - Sub-account that owns the source shares and receives destination shares
+     * @param args.fromAsset - Optional source underlying asset; defaults to the account position asset
+     * @param args.toAsset - Destination underlying asset, used to verify this is a same-asset migration
+     * @param args.isMax - If true, redeems shares instead of withdrawing assets
+     * @param args.maxShares - Optional exact share amount for max migration
+     * @param args.enableCollateralTo - Optional override for enabling destination collateral
+     * @param args.disableCollateralFrom - Optional override for disabling source collateral
+     * @returns Array of transaction plan items (EVC batch; no token approvals)
+     */
+    planMigrateSameAssetCollateral(args) {
+        const { account, fromVault, toVault, amount, positionAccount, fromAsset, toAsset, isMax = false, maxShares, enableCollateralTo, disableCollateralFrom, } = args;
+        const plan = [];
+        const sourcePosition = account?.getPosition(positionAccount, fromVault);
+        const resolvedFromAsset = fromAsset ?? sourcePosition?.asset;
+        if (!resolvedFromAsset) {
+            throw new Error(`Position not found. From vault: ${fromVault}, Account: ${positionAccount}. Source asset is required when position is not available.`);
+        }
+        if (getAddress(resolvedFromAsset) !== getAddress(toAsset)) {
+            throw new Error("planMigrateSameAssetCollateral only supports same-asset vault migrations. Use planSwapCollateral for cross-asset migrations.");
+        }
+        const shouldEnableCollateralTo = enableCollateralTo ??
+            !account.isCollateralEnabled(positionAccount, toVault);
+        const shouldDisableCollateralFrom = disableCollateralFrom ??
+            (isMax && account.isCollateralEnabled(positionAccount, fromVault));
+        const batchItems = this.encodeMigrateSameAssetCollateral({
+            chainId: account.chainId,
+            fromVault,
+            toVault,
+            amount,
+            account: positionAccount,
+            isMax,
+            maxShares: maxShares ?? (isMax ? sourcePosition?.shares : undefined),
+            enableCollateralTo: shouldEnableCollateralTo,
+            disableCollateralFrom: shouldDisableCollateralFrom,
+        });
+        plan.push(...this.convertBatchItemsToPlan(batchItems, "migrateSameAssetCollateral"));
+        return plan;
+    }
+    /**
+     * Builds a transaction plan for migrating a full same-asset debt position from one liability vault to another.
+     * This is the no-swap path for debt vault migration and repays the old vault with shares after borrowing
+     * slightly more from the new vault to cover interest accrual.
+     *
+     * @param args - Same-asset debt migration plan arguments
+     * @param args.oldLiabilityVault - Existing debt vault to fully repay and disable
+     * @param args.newLiabilityVault - New same-asset debt vault to borrow from
+     * @param args.liabilityAccount - Sub-account that owns the debt position
+     * @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.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)
+     */
+    planMigrateSameAssetDebt(args) {
+        const { account, oldLiabilityVault, newLiabilityVault, liabilityAccount, liabilityAmount, oldLiabilityAsset, newLiabilityAsset, sweepExcess = true, transferRemainingSharesToOwner = true, } = args;
+        const plan = [];
+        const oldPosition = account?.getPosition(liabilityAccount, oldLiabilityVault);
+        const resolvedOldAsset = oldLiabilityAsset ?? oldPosition?.asset;
+        if (!resolvedOldAsset) {
+            throw new Error(`Position not found. Old liability vault: ${oldLiabilityVault}, Account: ${liabilityAccount}. Old liability asset is required when position is not available.`);
+        }
+        if (getAddress(resolvedOldAsset) !== getAddress(newLiabilityAsset)) {
+            throw new Error("planMigrateSameAssetDebt only supports same-asset debt migrations. Use planSwapDebt for cross-asset migrations.");
+        }
+        const amount = liabilityAmount ?? oldPosition?.borrowed;
+        if (!amount || amount <= 0n) {
+            throw new Error(`Debt position not found or liability is 0. Old liability vault: ${oldLiabilityVault}, Account: ${liabilityAccount}`);
+        }
+        const enableController = !account.isControllerEnabled(liabilityAccount, newLiabilityVault);
+        const transferRemainingSharesTo = transferRemainingSharesToOwner &&
+            getAddress(liabilityAccount) !== getAddress(account.owner)
+            ? account.owner
+            : undefined;
+        const batchItems = this.encodeMigrateSameAssetDebt({
+            chainId: account.chainId,
+            oldLiabilityVault,
+            newLiabilityVault,
+            amount,
+            account: liabilityAccount,
+            enableController,
+            disableController: true,
+            sweepExcess,
+            transferRemainingSharesTo,
         });
+        plan.push(...this.convertBatchItemsToPlan(batchItems, "migrateSameAssetDebt"));
         return plan;
     }
     /**
@@ -1878,10 +1559,7 @@ export class ExecutionService {
             disableCollateralFrom: disableCollateralFrom &&
                 (account?.isCollateralEnabled(from, vault) ?? false),
         });
-        plan.push({
-            type: "evcBatch",
-            items: batchItems,
-        });
+        plan.push(...this.convertBatchItemsToPlan(batchItems, "transfer"));
         return plan;
     }
     /**
@@ -1908,10 +1586,7 @@ export class ExecutionService {
             to,
             enableController,
         });
-        plan.push({
-            type: "evcBatch",
-            items: batchItems,
-        });
+        plan.push(...this.convertBatchItemsToPlan(batchItems, "pullDebt"));
         return plan;
     }
     /**
@@ -1927,10 +1602,10 @@ 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, account, swapQuote, } = args;
+        const { collateralVault, collateralAmount, collateralAsset, collateralShareSource, account, swapQuote, } = args;
         const plan = [];
         // 1. Check if collateral approval is needed (only if depositing collateral)
-        if (collateralAmount > 0n) {
+        if (!collateralShareSource && collateralAmount > 0n) {
             // Add approval requirement (will be resolved later with Wallet data)
             plan.push({
                 type: "requiredApproval",
@@ -1948,8 +1623,19 @@ export class ExecutionService {
         const longVault = swapQuote.receiver;
         const liabilityAmount = BigInt(swapQuote.amountIn);
         // 2. Determine if collateral needs to be enabled
-        const enableCollateral = collateralAmount > 0n &&
+        const hasCollateralInput = collateralShareSource
+            ? collateralShareSource.shares > 0n
+            : collateralAmount > 0n;
+        const enableCollateral = hasCollateralInput &&
             !(account?.isCollateralEnabled(receiver, collateralVault) ?? false);
+        const resolvedCollateralShareSource = collateralShareSource
+            ? {
+                ...collateralShareSource,
+                disableCollateralFrom: collateralShareSource.disableCollateralFrom &&
+                    (account?.isCollateralEnabled(collateralShareSource.from, collateralVault) ??
+                        false),
+            }
+            : undefined;
         // 3. Determine if controller needs to be enabled
         const enableController = !(account?.isControllerEnabled(receiver, liabilityVault) ?? false);
         // 4. Get current controller (may need to disable if different)
@@ -1967,13 +1653,11 @@ export class ExecutionService {
             enableCollateral,
             currentController: currentController || undefined,
             enableController,
+            collateralShareSource: resolvedCollateralShareSource,
             swapQuote,
             // Permit2 is handled separately in the plan
         });
-        plan.push({
-            type: "evcBatch",
-            items: batchItems,
-        });
+        plan.push(...this.convertBatchItemsToPlan(batchItems, "multiplyWithSwap"));
         return plan;
     }
     /**
@@ -1992,10 +1676,10 @@ export class ExecutionService {
      * @returns Array of transaction plan items (optional approval + EVC batch)
      */
     planMultiplySameAsset(args) {
-        const { collateralVault, collateralAmount, collateralAsset, liabilityVault, liabilityAmount, longVault, receiver, account, } = args;
+        const { collateralVault, collateralAmount, collateralAsset, collateralShareSource, liabilityVault, liabilityAmount, longVault, receiver, account, } = args;
         const plan = [];
         // 1. Check if collateral approval is needed (only if depositing collateral)
-        if (collateralAmount > 0n) {
+        if (!collateralShareSource && collateralAmount > 0n) {
             // Add approval requirement (will be resolved later with Wallet data)
             plan.push({
                 type: "requiredApproval",
@@ -2006,8 +1690,19 @@ export class ExecutionService {
             });
         }
         // 2. Determine if collateral needs to be enabled
-        const enableCollateral = collateralAmount > 0n &&
+        const hasCollateralInput = collateralShareSource
+            ? collateralShareSource.shares > 0n
+            : collateralAmount > 0n;
+        const enableCollateral = hasCollateralInput &&
             !(account?.isCollateralEnabled(receiver, collateralVault) ?? false);
+        const resolvedCollateralShareSource = collateralShareSource
+            ? {
+                ...collateralShareSource,
+                disableCollateralFrom: collateralShareSource.disableCollateralFrom &&
+                    (account?.isCollateralEnabled(collateralShareSource.from, collateralVault) ??
+                        false),
+            }
+            : undefined;
         // 3. Determine if controller needs to be enabled
         const enableController = !(account?.isControllerEnabled(receiver, liabilityVault) ?? false);
         // 4. Get current controller (may need to disable if different)
@@ -2025,12 +1720,10 @@ export class ExecutionService {
             enableCollateral,
             currentController: currentController || undefined,
             enableController,
+            collateralShareSource: resolvedCollateralShareSource,
             // Permit2 is handled separately in the plan
         });
-        plan.push({
-            type: "evcBatch",
-            items: batchItems,
-        });
+        plan.push(...this.convertBatchItemsToPlan(batchItems, "multiplySameAsset"));
         return plan;
     }
 }