@eulerxyz/euler-v2-sdk 1.0.3 → 1.0.5

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

@@ -1,5 +1,70 @@
-import { decodeFunctionResult, getAddress, parseEther, } from "viem";
+import { decodeFunctionData, decodeFunctionResult, encodeFunctionData, getAddress, parseEther, toFunctionSelector, zeroAddress, } from "viem";
 import { estimateContractGas } from "viem/actions";
+// Minimal ABI for resolving a vault's underlying asset and reading wallet ERC20
+// balances inside the simulated batch (per-layer wallet-balance capture).
+const walletBalanceAbi = [
+    { type: "function", name: "asset", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
+    { type: "function", name: "balanceOf", stateMutability: "view", inputs: [{ type: "address" }], outputs: [{ type: "uint256" }] },
+    { type: "function", name: "underlying", stateMutability: "view", inputs: [], outputs: [{ type: "address" }] },
+];
+const merklClaimAbi = [
+    {
+        type: "function",
+        name: "claim",
+        inputs: [
+            { name: "users", type: "address[]" },
+            { name: "tokens", type: "address[]" },
+            { name: "amounts", type: "uint256[]" },
+            { name: "proofs", type: "bytes32[][]" },
+        ],
+        outputs: [],
+        stateMutability: "nonpayable",
+    },
+];
+const fuulClaimAbi = [
+    {
+        type: "function",
+        name: "claim",
+        inputs: [
+            {
+                name: "claimChecks",
+                type: "tuple[]",
+                components: [
+                    { name: "projectAddress", type: "address" },
+                    { name: "to", type: "address" },
+                    { name: "currency", type: "address" },
+                    { name: "currencyType", type: "uint8" },
+                    { name: "amount", type: "uint256" },
+                    { name: "reason", type: "uint8" },
+                    { name: "tokenId", type: "uint256" },
+                    { name: "deadline", type: "uint256" },
+                    { name: "proof", type: "bytes32" },
+                    { name: "signatures", type: "bytes[]" },
+                ],
+            },
+        ],
+        outputs: [],
+        stateMutability: "payable",
+    },
+];
+const rewardStreamsClaimAbi = [
+    {
+        type: "function",
+        name: "claimReward",
+        inputs: [
+            { name: "rewarded", type: "address" },
+            { name: "reward", type: "address" },
+            { name: "to", type: "address" },
+            { name: "ignoreRecentReward", type: "bool" },
+        ],
+        outputs: [{ name: "amount", type: "uint256" }],
+        stateMutability: "nonpayable",
+    },
+];
+const MERKL_CLAIM_SELECTOR = toFunctionSelector("function claim(address[],address[],uint256[],bytes32[][])");
+const FUUL_CLAIM_SELECTOR = toFunctionSelector("function claim((address,address,address,uint8,uint256,uint8,uint256,uint256,bytes32,bytes[])[])");
+const REWARD_STREAM_CLAIM_SELECTOR = toFunctionSelector("function claimReward(address,address,address,bool)");
+const REUL_UNLOCK_SELECTOR = toFunctionSelector("function withdrawToByLockTimestamp(address,uint256,bool)");
 import { Account, } from "../../entities/Account.js";
 import { EulerEarn } from "../../entities/EulerEarn.js";
 import { EVault } from "../../entities/EVault.js";
@@ -17,8 +82,13 @@ import { getEulerEarnVaultInfoFullLensBatchItem } from "../vaults/eulerEarnServi
 import { vaultLensAbi } from "../vaults/eVaultService/adapters/eVaultOnchainAdapter/abis/vaultLensAbi.js";
 import { getVaultInfoFullLensBatchItem } from "../vaults/eVaultService/adapters/eVaultOnchainAdapter/eVaultOnchainAdapter.js";
 import { convertVaultInfoFullToIEVault } from "../vaults/eVaultService/adapters/eVaultOnchainAdapter/vaultInfoConverter.js";
+import { SecuritizeCollateralVault } from "../../entities/SecuritizeCollateralVault.js";
+import { utilsLensAbi } from "../vaults/securitizeVaultService/adapters/abis/utilsLensAbi.js";
+import { erc4626EvcCollateralSecuritizeAbi } from "../vaults/securitizeVaultService/adapters/abis/erc4626EvcCollateralSecuritizeAbi.js";
+import { convertToISecuritizeCollateralVault } from "../vaults/securitizeVaultService/adapters/securitizeVaultInfoConverter.js";
+import { getVaultInfoERC4626LensBatchItem, getSecuritizeGovernorAdminBatchItem, getSecuritizeSupplyCapResolvedBatchItem, } from "../vaults/securitizeVaultService/adapters/securitizeVaultOnchainAdapter.js";
 import { ethereumVaultConnectorAbi } from "./abis/ethereumVaultConnectorAbi.js";
-import { assertNoCowSwapPlanItems, flattenBatchEntries, } from "./executionServiceTypes.js";
+import { assertNoCowSwapPlanItems, flattenBatchEntries, isEVCBatchOperation, } from "./executionServiceTypes.js";
 export async function deriveStateOverrides(ctx, chainId, account, transactionPlan, options) {
     assertNoCowSwapPlanItems(transactionPlan, "deriveStateOverrides");
     const owner = getAddress(account);
@@ -97,7 +167,11 @@ export async function simulateTransactionPlan(ctx, chainId, account, transaction
     if (useStateOverrides) {
         effectiveStateOverrides = await deriveStateOverrides(ctx, chainId, owner, transactionPlan, options?.stateOverrideOptions);
     }
-    const batch = transactionPlan.flatMap((item) => item.type === "evcBatch" ? flattenBatchEntries(item.items) : []);
+    // Preserve operation boundaries (EVCBatchOperation entries emitted by the
+    // planners / mergePlans) so reverts can be attributed to the operation that
+    // caused them and so we can snapshot state after each operation.
+    const operations = collectOperations(transactionPlan);
+    const batch = operations.flatMap((op) => op.items);
     if (batch.length === 0) {
         return {
             simulatedAccounts: [],
@@ -106,7 +180,32 @@ export async function simulateTransactionPlan(ctx, chainId, account, transaction
         };
     }
     const diagnostics = await fetchSimulationDiagnostics(ctx, chainId, owner, transactionPlan);
-    const { fullBatch, lensMeta, evcAddress, totalValue } = await buildSimulationBatch(ctx, chainId, owner, batch);
+    const { lensItems, lensMeta, evcAddress } = await buildSimulationBatch(ctx, chainId, owner, operations);
+    // Assemble the EVC batch, interleaving a lens-read block before the first
+    // operation (layer 0 = real state) and one after every operation (layer i =
+    // state after op i), so the full per-layer history is always captured.
+    const fullBatch = [];
+    const actionPositions = []; // fullBatch indices of real items, in `batch` order
+    const opOfPosition = []; // operation index for each action position
+    const layerSlices = [];
+    const pushLensBlock = () => {
+        layerSlices.push({ lensStart: fullBatch.length });
+        for (const it of lensItems)
+            fullBatch.push(it);
+    };
+    const pushOperation = (op, opIndex) => {
+        for (const it of op.items) {
+            actionPositions.push(fullBatch.length);
+            opOfPosition.push(opIndex);
+            fullBatch.push(it);
+        }
+    };
+    pushLensBlock();
+    for (let i = 0; i < operations.length; i++) {
+        pushOperation(operations[i], i);
+        pushLensBlock();
+    }
+    const totalValue = fullBatch.reduce((sum, item) => sum + item.value, 0n);
     const simulationResult = await runSimulation(ctx, chainId, account, evcAddress, fullBatch, totalValue, effectiveStateOverrides);
     if ("simulationError" in simulationResult) {
         return {
@@ -116,7 +215,7 @@ export async function simulateTransactionPlan(ctx, chainId, account, transaction
         };
     }
     const { batchResults, accountStatusErrors, vaultStatusErrors } = simulationResult;
-    const rawBatchResults = batchResults.slice(0, batch.length);
+    const rawBatchResults = actionPositions.map((pos) => batchResults[pos]);
     let describedBatch;
     try {
         describedBatch = ctx.describeBatch(batch);
@@ -131,27 +230,156 @@ export async function simulateTransactionPlan(ctx, chainId, account, transaction
         args: {},
     });
     const failedBatchItems = (await Promise.all(rawBatchResults.map(async (itemResult, index) => {
-        if (itemResult.success)
+        if (!itemResult || itemResult.success)
             return null;
         const decodedError = await decodeSmartContractErrors(itemResult.result);
         const decodedItem = describedBatch && describedBatch.length === batch.length
             ? describedBatch[index]
             : fallbackDescription(batch[index]);
+        const operationIndex = opOfPosition[index];
         return {
             index,
+            operationIndex,
+            operationName: operations[operationIndex]?.name,
             item: decodedItem,
             error: itemResult.result,
             decodedError,
         };
     }))).filter((item) => item !== null);
+    // One account/vault/wallet snapshot per layer: [pre-batch, after op0, after op1, …].
+    const snapshots = [];
+    for (const slice of layerSlices) {
+        snapshots.push(await decodeAccountSnapshot(ctx, chainId, owner, lensMeta, (i) => batchResults[slice.lensStart + i], options));
+    }
+    const simulatedAccounts = snapshots.map((s) => s.account);
+    const simulatedVaultsLayers = snapshots.map((s) => s.vaults);
+    const simulatedVaults = simulatedVaultsLayers[simulatedVaultsLayers.length - 1] ?? [];
+    const simulatedWalletBalances = snapshots.map((s) => s.walletBalances);
+    // Accurate wallet shortfall from the per-layer balances (running-min over the
+    // real-anchored balance), which nets out intra-batch funding. Prefer it when
+    // available; if an item reverted before wallet deltas could be observed, keep
+    // the static requiredApproval diagnostic from fetchSimulationDiagnostics.
+    const insufficientWalletAssets = (await computeWalletShortfall(ctx, chainId, owner, simulatedWalletBalances)) ?? diagnostics.insufficientWalletAssets;
+    const canExecute = failedBatchItems.length === 0 &&
+        accountStatusErrors.length === 0 &&
+        vaultStatusErrors.length === 0 &&
+        !insufficientWalletAssets?.length &&
+        !diagnostics.insufficientPermit2Allowances?.length &&
+        !diagnostics.insufficientDirectAllowances?.length;
+    return {
+        simulatedAccounts,
+        simulatedVaults,
+        simulatedVaultsLayers,
+        simulatedWalletBalances,
+        canExecute,
+        rawBatchResults,
+        failedBatchItems: failedBatchItems.length > 0 ? failedBatchItems : undefined,
+        accountStatusErrors: accountStatusErrors.length > 0 ? accountStatusErrors : undefined,
+        vaultStatusErrors: vaultStatusErrors.length > 0 ? vaultStatusErrors : undefined,
+        ...diagnostics,
+        insufficientWalletAssets,
+    };
+}
+function collectOperations(transactionPlan) {
+    const operations = [];
+    for (const item of transactionPlan) {
+        if (item.type !== "evcBatch")
+            continue;
+        for (const entry of item.items) {
+            if (isEVCBatchOperation(entry)) {
+                operations.push({
+                    name: entry.name,
+                    items: entry.items,
+                    walletBalanceTokens: entry.walletBalanceTokens,
+                });
+            }
+            else {
+                operations.push({ name: undefined, items: [entry] });
+            }
+        }
+    }
+    return operations;
+}
+const addWalletToken = (tokens, token) => {
+    if (!token)
+        return;
+    try {
+        const checksum = getAddress(token);
+        if (checksum !== zeroAddress)
+            tokens.add(checksum);
+    }
+    catch {
+        // Ignore malformed optional metadata / decoded calldata.
+    }
+};
+const getSelector = (data) => data.slice(0, 10);
+function collectClaimWalletBalanceTokens(batch) {
+    const tokens = new Set();
+    for (const item of batch) {
+        const selector = getSelector(item.data);
+        try {
+            if (selector === MERKL_CLAIM_SELECTOR) {
+                const decoded = decodeFunctionData({
+                    abi: merklClaimAbi,
+                    data: item.data,
+                });
+                const rewardTokens = decoded.args[1];
+                for (const token of rewardTokens)
+                    addWalletToken(tokens, token);
+                continue;
+            }
+            if (selector === FUUL_CLAIM_SELECTOR) {
+                const decoded = decodeFunctionData({
+                    abi: fuulClaimAbi,
+                    data: item.data,
+                });
+                const claimChecks = decoded.args[0];
+                for (const check of claimChecks) {
+                    addWalletToken(tokens, check.currency);
+                }
+                continue;
+            }
+            if (selector === REWARD_STREAM_CLAIM_SELECTOR) {
+                const decoded = decodeFunctionData({
+                    abi: rewardStreamsClaimAbi,
+                    data: item.data,
+                });
+                addWalletToken(tokens, decoded.args[1]);
+            }
+        }
+        catch {
+            // Unknown or malformed claim-like calldata should not block simulation.
+        }
+    }
+    return [...tokens];
+}
+// Decode the lens-read block for a single layer into a populated Account plus
+// the EVault/EulerEarn entities observed at that point in the batch.
+async function decodeAccountSnapshot(ctx, chainId, owner, lensMeta, resultAt, options) {
     const vaultsByAddress = new Map();
     const evcInfos = new Map();
     const vaultInfosBySub = new Map();
+    const walletBalances = {};
+    // Securitize collateral vaults are assembled from three separate reads
+    // (ERC4626 info via UtilsLens, plus governorAdmin and supplyCapResolved read
+    // directly off the vault), keyed by vault address and stitched after the loop.
+    const securitizeInfos = new Map();
+    const securitizeGovernors = new Map();
+    const securitizeSupplyCaps = new Map();
     for (let i = 0; i < lensMeta.length; i++) {
         const meta = lensMeta[i];
-        const resultItem = batchResults[batch.length + i];
+        const resultItem = resultAt(i);
         if (!resultItem?.success)
             continue;
+        if (meta.kind === "walletBalance") {
+            const bal = decodeFunctionResult({
+                abi: walletBalanceAbi,
+                functionName: "balanceOf",
+                data: resultItem.result,
+            });
+            walletBalances[getAddress(meta.token).toLowerCase()] = bal;
+            continue;
+        }
         if (meta.kind === "eVault") {
             const decodedVault = decodeFunctionResult({
                 abi: vaultLensAbi,
@@ -170,6 +398,30 @@ export async function simulateTransactionPlan(ctx, chainId, account, transaction
             const entity = new EulerEarn(convertEulerEarnVaultInfoFullToIEulerEarn(decodedVault, chainId, []));
             vaultsByAddress.set(getAddress(meta.vault), entity);
         }
+        if (meta.kind === "securitizeInfo") {
+            const decoded = decodeFunctionResult({
+                abi: utilsLensAbi,
+                functionName: "getVaultInfoERC4626",
+                data: resultItem.result,
+            });
+            securitizeInfos.set(getAddress(meta.vault), decoded);
+        }
+        if (meta.kind === "securitizeGovernor") {
+            const decoded = decodeFunctionResult({
+                abi: erc4626EvcCollateralSecuritizeAbi,
+                functionName: "governorAdmin",
+                data: resultItem.result,
+            });
+            securitizeGovernors.set(getAddress(meta.vault), decoded);
+        }
+        if (meta.kind === "securitizeSupplyCap") {
+            const decoded = decodeFunctionResult({
+                abi: erc4626EvcCollateralSecuritizeAbi,
+                functionName: "supplyCapResolved",
+                data: resultItem.result,
+            });
+            securitizeSupplyCaps.set(getAddress(meta.vault), decoded);
+        }
         if (meta.kind === "evcAccount") {
             const decodedAccount = decodeFunctionResult({
                 abi: accountLensAbi,
@@ -190,6 +442,18 @@ export async function simulateTransactionPlan(ctx, chainId, account, transaction
             vaultInfosBySub.set(key, list);
         }
     }
+    // Stitch the three Securitize reads into vault entities. Skip any vault whose
+    // governor/supply-cap read failed (kept undefined) so a partial read degrades
+    // to "no entity" rather than throwing — mirrors the per-vault tolerance above.
+    for (const [vault, info] of securitizeInfos.entries()) {
+        const governor = securitizeGovernors.get(vault);
+        const supplyCap = securitizeSupplyCaps.get(vault);
+        if (governor === undefined || supplyCap === undefined)
+            continue;
+        const conversionErrors = [];
+        const entity = new SecuritizeCollateralVault(convertToISecuritizeCollateralVault(info, governor, supplyCap, chainId, conversionErrors));
+        vaultsByAddress.set(vault, entity);
+    }
     const simulatedVaults = Array.from(vaultsByAddress.values());
     const vaultFetchOptions = options?.vaultFetchOptions ??
         options?.accountFetchOptions?.vaultFetchOptions;
@@ -240,22 +504,7 @@ export async function simulateTransactionPlan(ctx, chainId, account, transaction
     if (accountFetchOptions?.populateUserRewards && ctx.rewardsService) {
         await populatedAccount.populateUserRewards(ctx.rewardsService);
     }
-    const result = {
-        simulatedAccounts: [populatedAccount],
-        simulatedVaults,
-        canExecute: failedBatchItems.length === 0 &&
-            accountStatusErrors.length === 0 &&
-            vaultStatusErrors.length === 0 &&
-            !diagnostics.insufficientWalletAssets?.length &&
-            !diagnostics.insufficientPermit2Allowances?.length &&
-            !diagnostics.insufficientDirectAllowances?.length,
-        rawBatchResults,
-        failedBatchItems: failedBatchItems.length > 0 ? failedBatchItems : undefined,
-        accountStatusErrors: accountStatusErrors.length > 0 ? accountStatusErrors : undefined,
-        vaultStatusErrors: vaultStatusErrors.length > 0 ? vaultStatusErrors : undefined,
-        ...diagnostics,
-    };
-    return result;
+    return { account: populatedAccount, vaults: simulatedVaults, walletBalances };
 }
 export async function estimateGasForTransactionPlan(ctx, chainId, account, transactionPlan, options) {
     assertNoCowSwapPlanItems(transactionPlan, "estimateGasForTransactionPlan");
@@ -312,8 +561,47 @@ function getAccountAdapter(ctx, methodName) {
     const emptyPositionsAdapter = { fetchAccountVaults: async () => ({}) };
     return new AccountOnchainAdapter(ctx.providerService, ctx.deploymentService, emptyPositionsAdapter);
 }
-async function buildSimulationBatch(ctx, chainId, owner, batch) {
+async function buildSimulationBatch(ctx, chainId, owner, operations) {
+    const batch = operations.flatMap((op) => op.items);
     const { candidateVaults, subAccountVaults } = collectCandidateVaults(ctx, owner, batch);
+    // Each touched sub-account's account-level liquidity (health factor, current
+    // LTV, collateral/liability values) rides on its *controller* vault's
+    // getVaultAccountInfo. An op that only touches collateral vaults (e.g. a
+    // collateral withdraw or supply) wouldn't otherwise read the controller, so
+    // the simulated liquidity would stay at the pre-batch (stale) state. Pull each
+    // touched sub-account's enabled controllers and read them too, so liquidity is
+    // recomputed post-op for every operation, not just borrows/repays.
+    const ctrlProvider = ctx.providerService?.getProvider(chainId);
+    const touchedSubs = Array.from(subAccountVaults.keys());
+    if (ctrlProvider && touchedSubs.length) {
+        const evc = ctx.deploymentService.getDeployment(chainId).addresses.coreAddrs
+            .evc;
+        try {
+            const controllerResults = await ctrlProvider.multicall({
+                allowFailure: true,
+                contracts: touchedSubs.map((sub) => ({
+                    address: evc,
+                    abi: ethereumVaultConnectorAbi,
+                    functionName: "getControllers",
+                    args: [sub],
+                })),
+            });
+            touchedSubs.forEach((sub, i) => {
+                const r = controllerResults[i];
+                if (r?.status !== "success")
+                    return;
+                for (const controller of r.result ?? []) {
+                    const c = getAddress(controller);
+                    subAccountVaults.get(sub)?.add(c);
+                    candidateVaults.add(c);
+                }
+            });
+        }
+        catch {
+            // Best-effort: if controllers can't be fetched, liquidity may stay stale
+            // for collateral-only ops, but the simulation itself is unaffected.
+        }
+    }
     const vaultCandidatesList = Array.from(candidateVaults);
     if (!ctx.vaultMetaService) {
         throw new Error("ExecutionService.simulateTransactionPlan requires a vaultMetaService. Pass it to the ExecutionService constructor or call setVaultMetaService().");
@@ -322,23 +610,28 @@ async function buildSimulationBatch(ctx, chainId, owner, batch) {
     const validVaults = new Set();
     const eVaults = [];
     const eulerEarnVaults = [];
+    const securitizeVaults = [];
     for (const vault of vaultCandidatesList) {
         const key = getAddress(vault);
         const type = vaultTypes[key];
         if (!type)
             continue;
-        if (type === VaultType.SecuritizeCollateral)
-            continue;
         validVaults.add(key);
         if (type === VaultType.EVault)
             eVaults.push(key);
         if (type === VaultType.EulerEarn)
             eulerEarnVaults.push(key);
+        // Securitize RWA collaterals are real Euler collateral vaults; keep them in
+        // validVaults so their per-account position (getVaultAccountInfo) is read,
+        // and queue the dedicated reads below so the vault entity is resolved too.
+        if (type === VaultType.SecuritizeCollateral)
+            securitizeVaults.push(key);
     }
     const deployment = ctx.deploymentService.getDeployment(chainId);
     const accountLensAddress = deployment.addresses.lensAddrs.accountLens;
     const vaultLensAddress = deployment.addresses.lensAddrs.vaultLens;
     const eulerEarnLensAddress = deployment.addresses.lensAddrs.eulerEarnVaultLens;
+    const utilsLensAddress = deployment.addresses.lensAddrs.utilsLens;
     const evcAddress = deployment.addresses.coreAddrs.evc;
     const lensItems = [];
     const lensMeta = [];
@@ -358,6 +651,20 @@ async function buildSimulationBatch(ctx, chainId, owner, batch) {
             vault,
         });
     }
+    for (const vault of securitizeVaults) {
+        pushLensItem(getVaultInfoERC4626LensBatchItem(utilsLensAddress, vault, owner), {
+            kind: "securitizeInfo",
+            vault,
+        });
+        pushLensItem(getSecuritizeGovernorAdminBatchItem(vault, owner), {
+            kind: "securitizeGovernor",
+            vault,
+        });
+        pushLensItem(getSecuritizeSupplyCapResolvedBatchItem(vault, owner), {
+            kind: "securitizeSupplyCap",
+            vault,
+        });
+    }
     for (const [subAccount, vaults] of subAccountVaults.entries()) {
         pushLensItem(getEVCAccountInfoLensBatchItem(accountLensAddress, evcAddress, subAccount, owner), {
             kind: "evcAccount",
@@ -373,9 +680,71 @@ async function buildSimulationBatch(ctx, chainId, owner, batch) {
             });
         }
     }
-    const fullBatch = [...batch, ...lensItems];
-    const totalValue = fullBatch.reduce((sum, item) => sum + item.value, 0n);
-    return { fullBatch, lensMeta, evcAddress, totalValue };
+    // Wallet-balance reads: resolve the underlying asset of each touched vault,
+    // plus reward tokens from claim/unlock operations, and read balanceOf(owner)
+    // for each token. Interleaved per layer like the other lens reads, so wallet
+    // balances are captured after every operation. Balances are forged by state
+    // overrides, so consumers stitch using the delta vs the pre-batch layer.
+    const provider = ctx.providerService?.getProvider(chainId);
+    if (provider) {
+        const vaultsForAssets = [...eVaults, ...eulerEarnVaults, ...securitizeVaults];
+        const assets = await Promise.all(vaultsForAssets.map((vault) => provider
+            .readContract({
+            address: vault,
+            abi: walletBalanceAbi,
+            functionName: "asset",
+        })
+            .then((a) => getAddress(a))
+            .catch(() => null)));
+        const assetTokens = new Set();
+        for (const a of assets)
+            if (a)
+                assetTokens.add(getAddress(a));
+        for (const operation of operations) {
+            for (const token of operation.walletBalanceTokens ?? []) {
+                addWalletToken(assetTokens, token);
+            }
+        }
+        for (const token of collectClaimWalletBalanceTokens(batch)) {
+            addWalletToken(assetTokens, token);
+        }
+        const unlockItems = batch.filter((item) => getSelector(item.data) === REUL_UNLOCK_SELECTOR);
+        if (unlockItems.length > 0) {
+            const configuredEul = deployment.addresses.tokenAddrs?.EUL;
+            if (configuredEul) {
+                addWalletToken(assetTokens, configuredEul);
+            }
+            else {
+                const underlyingTokens = await Promise.all(unlockItems.map((item) => provider
+                    .readContract({
+                    address: item.targetContract,
+                    abi: walletBalanceAbi,
+                    functionName: "underlying",
+                })
+                    .then((a) => getAddress(a))
+                    .catch(() => null)));
+                for (const token of underlyingTokens) {
+                    if (token)
+                        addWalletToken(assetTokens, token);
+                }
+            }
+        }
+        for (const token of assetTokens) {
+            pushLensItem({
+                targetContract: token,
+                onBehalfOfAccount: owner,
+                value: 0n,
+                data: encodeFunctionData({
+                    abi: walletBalanceAbi,
+                    functionName: "balanceOf",
+                    args: [owner],
+                }),
+            }, { kind: "walletBalance", token });
+        }
+    }
+    // The caller assembles the final batch (interleaving these lens reads per the
+    // chosen layers mode), so we just return the reusable lens block.
+    return { lensItems, lensMeta, evcAddress };
 }
 function collectCandidateVaults(ctx, owner, batch) {
     const candidateVaults = new Set();
@@ -399,9 +768,20 @@ function collectCandidateVaults(ctx, owner, batch) {
     for (const item of described) {
         const fn = item.functionName.toLowerCase();
         const target = getAddress(item.targetContract);
-        if (fn === "transfer" || fn === "transferfrom") {
+        if (fn === "enablecollateral" ||
+            fn === "disablecollateral" ||
+            fn === "enablecontroller") {
+            const account = item.args.account;
+            const vault = item.args.vault;
+            if (vault)
+                addCandidateVault(vault);
+            if (account && vault)
+                addSubAccountVault(account, vault);
+            continue;
+        }
+        if (fn === "transfer" || fn === "transferfrom" || fn === "transferfrommax") {
             const to = item.args.to;
-            const from = fn === "transferfrom"
+            const from = fn === "transferfrom" || fn === "transferfrommax"
                 ? item.args.from
                 : (item.args.from ?? item.onBehalfOfAccount);
             if (from)
@@ -411,12 +791,68 @@ function collectCandidateVaults(ctx, owner, batch) {
             addCandidateVault(target);
             continue;
         }
+        if (fn === "withdraw" || fn === "redeem") {
+            const owner = item.args.owner;
+            if (owner)
+                addSubAccountVault(owner, target);
+            addCandidateVault(target);
+            continue;
+        }
+        if (fn === "liquidate") {
+            const violator = item.args.violator;
+            const collateral = item.args.collateral;
+            if (violator)
+                addSubAccountVault(violator, target);
+            if (violator && collateral)
+                addSubAccountVault(violator, collateral);
+            if (collateral) {
+                addSubAccountVault(item.onBehalfOfAccount, collateral);
+                addCandidateVault(collateral);
+            }
+            addCandidateVault(target);
+            continue;
+        }
+        if (fn === "pulldebt") {
+            const from = item.args.from;
+            if (from)
+                addSubAccountVault(from, target);
+            addCandidateVault(target);
+            continue;
+        }
         if (fn === "deposit" || fn === "skim" || fn === "mint") {
             const receiver = item.args.receiver;
             if (receiver)
                 addSubAccountVault(receiver, target);
             addCandidateVault(target);
         }
+        // repay(amount, receiver) / repayWithShares(amount, receiver): the *receiver*
+        // is the account whose debt is reduced, and it can differ from the batch
+        // item's onBehalfOfAccount (e.g. a repay-from-wallet runs on behalf of the
+        // owner but repays a sub-account's debt). Map the receiver so its post-repay
+        // debt position (and liquidity) is read — otherwise the simulated debt/health
+        // of the repaid sub-account stays at the pre-batch state.
+        if (fn === "repay" || fn === "repaywithshares") {
+            const receiver = item.args.receiver;
+            if (receiver)
+                addSubAccountVault(receiver, target);
+            addCandidateVault(target);
+        }
+        if (fn === "verifyamountminanddeposit" || fn === "verifyamountminandskim") {
+            const vault = item.args.vault;
+            const receiver = item.args.receiver;
+            if (vault)
+                addCandidateVault(vault);
+            if (vault && receiver)
+                addSubAccountVault(receiver, vault);
+        }
+        if (fn === "verifydebtmax") {
+            const vault = item.args.vault;
+            const account = item.args.account;
+            if (vault)
+                addCandidateVault(vault);
+            if (vault && account)
+                addSubAccountVault(account, vault);
+        }
     }
     if (!subAccountVaults.has(owner)) {
         subAccountVaults.set(owner, new Set());
@@ -476,6 +912,50 @@ async function runSimulation(ctx, chainId, account, evcAddress, fullBatch, total
     })));
     return { batchResults, accountStatusErrors, vaultStatusErrors };
 }
+/**
+ * Wallet shortfall derived from the per-layer simulated balances. In-sim
+ * balances are forged by state overrides, so we anchor to the real on-chain
+ * balance and track the running balance across layers — real balance plus each
+ * layer's net delta vs the pre-batch layer. The shortfall per token is the worst
+ * dip below zero. This nets out intra-batch funding (e.g. withdraw then deposit
+ * the same asset → never dips) yet still flags a step that consumes more than is
+ * genuinely available at that point. Returns undefined when balances can't be
+ * resolved (no walletService / no touched tokens), so callers don't over-block.
+ */
+async function computeWalletShortfall(ctx, chainId, owner, simulatedWalletBalances) {
+    if (!ctx.walletService || simulatedWalletBalances.length === 0)
+        return undefined;
+    const base = simulatedWalletBalances[0] ?? {};
+    const tokens = Object.keys(base);
+    if (tokens.length === 0)
+        return undefined;
+    let realByToken;
+    try {
+        const wallet = (await ctx.walletService.fetchWallet(chainId, owner, tokens.map((t) => ({ asset: getAddress(t), spenders: [] })))).result;
+        realByToken = {};
+        for (const t of tokens)
+            realByToken[t] = wallet.getBalance(getAddress(t));
+    }
+    catch {
+        return undefined;
+    }
+    const shortfalls = [];
+    for (const t of tokens) {
+        const baseBal = base[t] ?? 0n;
+        const real = realByToken[t] ?? 0n;
+        // Worst running balance across layers (layer 0's delta is 0 ⇒ starts at real).
+        let minAvailable = real;
+        for (let i = 1; i < simulatedWalletBalances.length; i++) {
+            const delta = (simulatedWalletBalances[i][t] ?? 0n) - baseBal;
+            const available = real + delta;
+            if (available < minAvailable)
+                minAvailable = available;
+        }
+        if (minAvailable < 0n)
+            shortfalls.push({ token: getAddress(t), amount: -minAvailable });
+    }
+    return shortfalls.length > 0 ? shortfalls : undefined;
+}
 async function fetchSimulationDiagnostics(ctx, chainId, account, transactionPlan) {
     if (!ctx.walletService || !transactionPlan)
         return {};
@@ -549,20 +1029,25 @@ async function fetchSimulationDiagnostics(ctx, chainId, account, transactionPlan
             : {}),
     };
 }
-function extractBalanceRequirements(transactionPlan, account) {
-    const maxPerToken = new Map();
+// Sum the required amount per token across every approval the owner must fund.
+// Each requiredApproval is a wallet outflow, and several can draw on the same
+// token within one batch (e.g. supplying it into two vaults, or supply + repay),
+// so the wallet must cover their *total*, not the largest single one. Forging
+// the sum lets an underfunded batch simulate through to completion — so the
+// running-balance shortfall reports the true peak deficit instead of the batch
+// reverting partway with E_InsufficientBalance. Over-forging is harmless: the
+// shortfall is computed against the real balance, not this forged amount.
+export function extractBalanceRequirements(transactionPlan, account) {
+    const totalPerToken = new Map();
     for (const item of transactionPlan) {
         if (item.type !== "requiredApproval")
             continue;
         if (getAddress(item.owner) !== getAddress(account))
             continue;
         const token = getAddress(item.token);
-        const current = maxPerToken.get(token) ?? 0n;
-        if (item.amount > current) {
-            maxPerToken.set(token, item.amount);
-        }
+        totalPerToken.set(token, (totalPerToken.get(token) ?? 0n) + item.amount);
     }
-    return Array.from(maxPerToken.entries());
+    return Array.from(totalPerToken.entries());
 }
 function extractApprovalRequirements(transactionPlan, account) {
     const seen = new Set();