@morpho-org/evm-simulation 3.0.0 → 4.0.1

package/lib/cjs/index.d.ts

@@ -1,3 +1,3 @@
 export { BlacklistViolationError, ExternalServiceError, SimulationPackageError, SimulationRevertedError, SimulationValidationError, UnsupportedChainError, } from "./errors.js";
 export { simulate } from "./simulate/index.js";
-export type { ChainSimulationConfig, RawLog, SimulateParams, SimulationAuthorization, SimulationCall, SimulationConfig, SimulationLogger, SimulationResult, SimulationTransaction, TenderlyRpcConfig, Transfer, } from "./types.js";
+export type { AccountAssetChanges, AssetChange, ChainSimulationConfig, RawLog, SimulateParams, SimulationAuthorization, SimulationCall, SimulationConfig, SimulationLogger, SimulationResult, SimulationTransaction, TenderlyRpcConfig, Transfer, } from "./types.js";

package/lib/cjs/simulate/asset-changes.d.ts

@@ -0,0 +1,19 @@
+import { type Address } from "viem";
+import type { AccountAssetChanges } from "../types.js";
+/** A single signed contribution to one account's balance for one token. */
+export interface AssetChangeEntry {
+    account: Address;
+    token: Address;
+    diff: bigint;
+    symbol?: string;
+    decimals?: number;
+}
+/**
+ * Net signed per-(account, token) contributions into balance changes grouped by
+ * account. Accounts and their `changes` are sorted by address for deterministic
+ * output; zero-net tokens and accounts are dropped.
+ *
+ * @param entries - Signed contributions; `diff` is added per (account, token).
+ * @returns One {@link AccountAssetChanges} per account with a non-zero change.
+ */
+export declare function groupAssetChanges(entries: AssetChangeEntry[]): AccountAssetChanges[];

package/lib/cjs/simulate/asset-changes.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupAssetChanges = groupAssetChanges;
+const viem_1 = require("viem");
+// Locale-independent byte-order compare on lowercased hex, matching `sortTransfers`.
+const compareAddress = (a, b) => {
+    const al = a.toLowerCase();
+    const bl = b.toLowerCase();
+    return al < bl ? -1 : al > bl ? 1 : 0;
+};
+/**
+ * Net signed per-(account, token) contributions into balance changes grouped by
+ * account. Accounts and their `changes` are sorted by address for deterministic
+ * output; zero-net tokens and accounts are dropped.
+ *
+ * @param entries - Signed contributions; `diff` is added per (account, token).
+ * @returns One {@link AccountAssetChanges} per account with a non-zero change.
+ */
+function groupAssetChanges(entries) {
+    const byAccount = new Map();
+    for (const entry of entries) {
+        if (entry.diff === 0n)
+            continue;
+        const account = (0, viem_1.getAddress)(entry.account);
+        // `token` is normalized by callers (checksummed contract or `ethAddress`).
+        const token = entry.token;
+        let tokens = byAccount.get(account);
+        if (!tokens)
+            byAccount.set(account, (tokens = new Map()));
+        const prev = tokens.get(token);
+        tokens.set(token, {
+            token,
+            symbol: prev?.symbol ?? entry.symbol,
+            decimals: prev?.decimals ?? entry.decimals,
+            diff: (prev?.diff ?? 0n) + entry.diff,
+        });
+    }
+    return [...byAccount]
+        .map(([account, tokens]) => ({
+        account,
+        changes: [...tokens.values()]
+            .filter((c) => c.diff !== 0n)
+            .sort((x, y) => compareAddress(x.token, y.token)),
+    }))
+        .filter((a) => a.changes.length > 0)
+        .sort((a, b) => compareAddress(a.account, b.account));
+}

package/lib/cjs/simulate/backends/eth-simulate-v1.d.ts

@@ -5,6 +5,15 @@ import type { RawSimulationResult, SimulationTransaction } from "../../types.js"
  *
  * Uses stateOverride to set the user's ETH balance high enough to avoid
  * false "insufficient balance for gas" reverts.
+ *
+ * Derives `assetChanges` (net per-token deltas grouped by account) from the
+ * emitted transfer logs, plus native ETH from each transaction's top-level
+ * `value` (payer debited, recipient credited, under viem's `ethAddress`).
+ *
+ * Coverage on this path is therefore narrower than the Tenderly backend:
+ * native ETH moved through internal calls (e.g. a `WETH.withdraw` refund, a
+ * swap that pays out ETH) emits no log and is not reflected in `value`, so it
+ * is not captured. For full native-ETH accounting use Tenderly.
  */
 export declare function simulateV1(params: {
     rpcUrl: string;

package/lib/cjs/simulate/backends/eth-simulate-v1.js

@@ -3,11 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.simulateV1 = simulateV1;
 const viem_1 = require("viem");
 const errors_js_1 = require("../../errors.js");
+const asset_changes_js_1 = require("../asset-changes.js");
+const index_js_1 = require("../parsing/index.js");
 /**
  * Simulate transactions using eth_simulateV1 (viem simulateCalls).
  *
  * Uses stateOverride to set the user's ETH balance high enough to avoid
  * false "insufficient balance for gas" reverts.
+ *
+ * Derives `assetChanges` (net per-token deltas grouped by account) from the
+ * emitted transfer logs, plus native ETH from each transaction's top-level
+ * `value` (payer debited, recipient credited, under viem's `ethAddress`).
+ *
+ * Coverage on this path is therefore narrower than the Tenderly backend:
+ * native ETH moved through internal calls (e.g. a `WETH.withdraw` refund, a
+ * swap that pays out ETH) emits no log and is not reflected in `value`, so it
+ * is not captured. For full native-ETH accounting use Tenderly.
  */
 async function simulateV1(params) {
     const { rpcUrl, transactions, blockNumber, signal } = params;
@@ -64,7 +75,13 @@ async function simulateV1(params) {
             returnData: r.data ?? "0x",
             gasUsed: r.gasUsed,
         }));
-        return { calls: rawCalls };
+        return {
+            calls: rawCalls,
+            assetChanges: toAssetChanges({
+                transfers: (0, index_js_1.parseTransfers)(rawCalls),
+                transactions,
+            }),
+        };
     }
     catch (error) {
         if (error instanceof errors_js_1.SimulationRevertedError)
@@ -74,3 +91,24 @@ async function simulateV1(params) {
         throw new errors_js_1.ExternalServiceError(`eth_simulateV1 error: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
 }
+/**
+ * Reduce parsed transfer logs and top-level transaction values to net per-token
+ * balance changes grouped by account. Native ETH is taken from the top-level
+ * `value`s (payer debited, recipient credited — internal moves are not logged,
+ * see `simulateV1` for the coverage caveat).
+ */
+function toAssetChanges(params) {
+    const { transfers, transactions } = params;
+    const entries = [];
+    for (const tx of transactions) {
+        if (!tx.value)
+            continue;
+        entries.push({ account: tx.from, token: viem_1.ethAddress, diff: -tx.value });
+        entries.push({ account: tx.to, token: viem_1.ethAddress, diff: tx.value });
+    }
+    for (const { token, from, to, amount } of transfers) {
+        entries.push({ account: to, token, diff: amount });
+        entries.push({ account: from, token, diff: -amount });
+    }
+    return (0, asset_changes_js_1.groupAssetChanges)(entries);
+}

package/lib/cjs/simulate/backends/tenderly-rpc.js

@@ -4,6 +4,7 @@ exports.simulateTenderlyRpc = simulateTenderlyRpc;
 const viem_1 = require("viem");
 const zod_1 = require("zod");
 const errors_js_1 = require("../../errors.js");
+const asset_changes_js_1 = require("../asset-changes.js");
 const addressSchema = zod_1.z.custom((val) => typeof val === "string" && (0, viem_1.isAddress)(val));
 const hexSchema = zod_1.z.custom((val) => typeof val === "string" && (0, viem_1.isHex)(val));
 const traceFrameSchema = zod_1.z
@@ -25,13 +26,27 @@ const logSchema = zod_1.z
         .optional(),
 })
     .passthrough();
+const assetChangeSchema = zod_1.z
+    .object({
+    assetInfo: zod_1.z
+        .object({
+        contractAddress: addressSchema.optional(),
+        symbol: zod_1.z.string().optional(),
+        decimals: zod_1.z.number().optional(),
+    })
+        .passthrough(),
+    from: addressSchema.optional(),
+    to: addressSchema.optional(),
+    rawAmount: hexSchema,
+})
+    .passthrough();
 const simResultSchema = zod_1.z
     .object({
     status: zod_1.z.boolean(),
     gasUsed: hexSchema,
     logs: zod_1.z.array(logSchema).optional(),
     trace: zod_1.z.array(traceFrameSchema).optional(),
-    assetChanges: zod_1.z.unknown().optional(),
+    assetChanges: zod_1.z.array(assetChangeSchema).optional(),
     error: zod_1.z.string().optional(),
     errorMessage: zod_1.z.string().optional(),
 })
@@ -84,7 +99,10 @@ async function simulateTenderlyRpc(params) {
                 signal,
             });
             const result = unwrapResult(singleEnvelope.parse(json));
-            return { calls: [toRawCall(result)] };
+            return {
+                calls: [toRawCall(result)],
+                assetChanges: toAssetChanges([result]),
+            };
         }
         const json = await rpcRequest({
             rpcUrl: config.rpcUrl,
@@ -92,8 +110,11 @@ async function simulateTenderlyRpc(params) {
             params: [transactions.map(buildCall), block, stateOverrides],
             signal,
         });
-        const result = unwrapResult(bundleEnvelope.parse(json));
-        return { calls: result.map(toRawCall) };
+        const results = unwrapResult(bundleEnvelope.parse(json));
+        return {
+            calls: results.map(toRawCall),
+            assetChanges: toAssetChanges(results),
+        };
     }
     catch (error) {
         if (error instanceof errors_js_1.SimulationRevertedError)
@@ -171,6 +192,39 @@ function toRawCall(data) {
         status: true,
         returnData: data.trace?.[0]?.output ?? "0x",
         gasUsed: BigInt(data.gasUsed),
-        assetChanges: data.assetChanges,
     };
 }
+/**
+ * Reduce Tenderly's per-transfer asset changes to net per-token balance changes
+ * grouped by account. Both endpoints of each transfer are accounted (sender,
+ * counterparties, and the zero address for mints/burns).
+ */
+function toAssetChanges(results) {
+    const entries = [];
+    for (const result of results) {
+        for (const change of result.assetChanges ?? []) {
+            const amount = BigInt(change.rawAmount);
+            const token = change.assetInfo.contractAddress
+                ? (0, viem_1.getAddress)(change.assetInfo.contractAddress)
+                : viem_1.ethAddress;
+            const { symbol, decimals } = change.assetInfo;
+            if (change.to)
+                entries.push({
+                    account: change.to,
+                    token,
+                    diff: amount,
+                    symbol,
+                    decimals,
+                });
+            if (change.from)
+                entries.push({
+                    account: change.from,
+                    token,
+                    diff: -amount,
+                    symbol,
+                    decimals,
+                });
+        }
+    }
+    return (0, asset_changes_js_1.groupAssetChanges)(entries);
+}

package/lib/cjs/simulate/pipeline/bundler-retention.d.ts

@@ -9,11 +9,11 @@ interface AssertNoBundlerRetentionParams {
  *
  * Uses net flow (inbound minus outbound) per (bundler address, token) pair.
  * Bundler3 legitimately receives tokens as an intermediary (user → bundler3 →
- * vault), so gross inbound would fire false positives. We only flag when
- * `|net| > DUST_THRESHOLD` — catching both **retention** (tokens stuck in
- * bundler, positive net) and **drain** (bundler sending more than it received
- * in this bundle, negative net — which implies a pre-existing or state-override
- * balance is being drawn down, a red flag for pre-broadcast integrity).
+ * vault), so gross inbound would fire false positives. We only block positive
+ * net flow above `DUST_THRESHOLD` — tokens stuck in a bundler address. Negative
+ * net flow means the simulated bundle sweeps a pre-existing or state-overridden
+ * bundler balance. That is useful telemetry, but not current-bundle retention,
+ * so it is warned instead of raising a blacklist violation.
  */
 export declare function assertNoBundlerRetention(params: AssertNoBundlerRetentionParams): void;
 export {};

package/lib/cjs/simulate/pipeline/bundler-retention.js

@@ -47,11 +47,11 @@ function getBundlerAddresses(chainId, logger) {
  *
  * Uses net flow (inbound minus outbound) per (bundler address, token) pair.
  * Bundler3 legitimately receives tokens as an intermediary (user → bundler3 →
- * vault), so gross inbound would fire false positives. We only flag when
- * `|net| > DUST_THRESHOLD` — catching both **retention** (tokens stuck in
- * bundler, positive net) and **drain** (bundler sending more than it received
- * in this bundle, negative net — which implies a pre-existing or state-override
- * balance is being drawn down, a red flag for pre-broadcast integrity).
+ * vault), so gross inbound would fire false positives. We only block positive
+ * net flow above `DUST_THRESHOLD` — tokens stuck in a bundler address. Negative
+ * net flow means the simulated bundle sweeps a pre-existing or state-overridden
+ * bundler balance. That is useful telemetry, but not current-bundle retention,
+ * so it is warned instead of raising a blacklist violation.
  */
 function assertNoBundlerRetention(params) {
     const { chainId, transfers, logger } = params;
@@ -77,15 +77,23 @@ function assertNoBundlerRetention(params) {
         if (bundlerAddresses.has(t.from))
             recordFlow(t.from, t.token, -t.amount);
     }
-    const flagged = [...flow.values()].filter((e) => absBigInt(e.netChange) > DUST_THRESHOLD);
-    if (flagged.length > 0) {
-        throw new errors_js_1.BlacklistViolationError("Simulation detected asset transfers retained or drained by restricted bundler contracts", flagged.map((e) => ({
+    const entries = [...flow.values()];
+    const drained = entries.filter((e) => e.netChange < -DUST_THRESHOLD);
+    if (drained.length > 0) {
+        logger?.warn("Simulation detected pre-existing bundler balance being swept", {
+            changes: drained.map((e) => ({
+                address: e.address,
+                token: e.token,
+                netSwept: (-e.netChange).toString(),
+            })),
+        });
+    }
+    const retained = entries.filter((e) => e.netChange > DUST_THRESHOLD);
+    if (retained.length > 0) {
+        throw new errors_js_1.BlacklistViolationError("Simulation detected asset transfers retained by restricted bundler contracts", retained.map((e) => ({
             address: e.address,
             token: e.token,
             netRetained: e.netChange.toString(),
         })));
     }
 }
-function absBigInt(x) {
-    return x < 0n ? -x : x;
-}

package/lib/cjs/simulate/simulate.d.ts

@@ -9,8 +9,10 @@ import type { SimulateParams, SimulationConfig, SimulationResult } from "../type
  *
  * - `transfers` → user-facing preview / server-side verification.
  * - `simulationTxs` + `transfers` → server-side verification before broadcast.
- * - `calls[i]` → per-tx raw backend output (`logs`, `status`, `returnData`, `gasUsed`,
- *   and Tenderly-only `assetChanges`). Aligned 1:1 with `simulationTxs[i]`.
+ * - `calls[i]` → per-tx raw backend output (`logs`, `status`, `returnData`, `gasUsed`).
+ *   Aligned 1:1 with `simulationTxs[i]`.
+ * - `assetChanges` → net per-asset balance changes grouped by account (sender and
+ *   counterparties) over the whole bundle, normalized to the same shape across backends.
  * - `transfers[k].txIdx` → index into `simulationTxs` of the tx that emitted the
  *   underlying log; consumers map back via `simulationTxs[transfer.txIdx]`.
  *
@@ -27,15 +29,15 @@ import type { SimulateParams, SimulationConfig, SimulationResult } from "../type
  *   empty transactions, malformed authorizations).
  * @throws {UnsupportedChainError} when the chain is not configured for any backend.
  * @throws {SimulationRevertedError} when the bundle reverts on either backend.
- * @throws {BlacklistViolationError} when the simulation leaves value retained by or
- *   drained from a `bundler3` address beyond the dust threshold.
+ * @throws {BlacklistViolationError} when the simulation leaves value retained by
+ *   a `bundler3` address beyond the dust threshold.
  * @throws {ExternalServiceError} (a) when both backends are unavailable within the
  *   timeout budget, or (b) when a backend returns a `calls` array whose length does
  *   not match the resolved `simulationTxs` — refusing to map transfers with mismatched
  *   per-tx output.
  * @returns A {@link SimulationResult} carrying the resolved `simulationTxs`, per-tx
- *   `calls` (aligned 1:1 with `simulationTxs`), and parsed `transfers` (each stamped
- *   with `txIdx`).
+ *   `calls` (aligned 1:1 with `simulationTxs`), parsed `transfers` (each stamped
+ *   with `txIdx`), and per-account net `assetChanges`.
  * @example
  * ```ts
  * import { simulate } from "@morpho-org/evm-simulation";

package/lib/cjs/simulate/simulate.js

@@ -14,8 +14,10 @@ const index_js_2 = require("./pipeline/index.js");
  *
  * - `transfers` → user-facing preview / server-side verification.
  * - `simulationTxs` + `transfers` → server-side verification before broadcast.
- * - `calls[i]` → per-tx raw backend output (`logs`, `status`, `returnData`, `gasUsed`,
- *   and Tenderly-only `assetChanges`). Aligned 1:1 with `simulationTxs[i]`.
+ * - `calls[i]` → per-tx raw backend output (`logs`, `status`, `returnData`, `gasUsed`).
+ *   Aligned 1:1 with `simulationTxs[i]`.
+ * - `assetChanges` → net per-asset balance changes grouped by account (sender and
+ *   counterparties) over the whole bundle, normalized to the same shape across backends.
  * - `transfers[k].txIdx` → index into `simulationTxs` of the tx that emitted the
  *   underlying log; consumers map back via `simulationTxs[transfer.txIdx]`.
  *
@@ -32,15 +34,15 @@ const index_js_2 = require("./pipeline/index.js");
  *   empty transactions, malformed authorizations).
  * @throws {UnsupportedChainError} when the chain is not configured for any backend.
  * @throws {SimulationRevertedError} when the bundle reverts on either backend.
- * @throws {BlacklistViolationError} when the simulation leaves value retained by or
- *   drained from a `bundler3` address beyond the dust threshold.
+ * @throws {BlacklistViolationError} when the simulation leaves value retained by
+ *   a `bundler3` address beyond the dust threshold.
  * @throws {ExternalServiceError} (a) when both backends are unavailable within the
  *   timeout budget, or (b) when a backend returns a `calls` array whose length does
  *   not match the resolved `simulationTxs` — refusing to map transfers with mismatched
  *   per-tx output.
  * @returns A {@link SimulationResult} carrying the resolved `simulationTxs`, per-tx
- *   `calls` (aligned 1:1 with `simulationTxs`), and parsed `transfers` (each stamped
- *   with `txIdx`).
+ *   `calls` (aligned 1:1 with `simulationTxs`), parsed `transfers` (each stamped
+ *   with `txIdx`), and per-account net `assetChanges`.
  * @example
  * ```ts
  * import { simulate } from "@morpho-org/evm-simulation";
@@ -84,5 +86,6 @@ async function simulate(config, params) {
         simulationTxs,
         calls: result.calls,
         transfers,
+        assetChanges: result.assetChanges,
     };
 }

package/lib/cjs/types.d.ts

@@ -64,6 +64,33 @@ export type SimulationAuthorization = {
     /** Defaults to maxUint256. Caller can set explicit amount for tokens that don't support max approval. */
     amount?: bigint;
 };
+/**
+ * Net balance change for a single asset (one token) within an account's entry.
+ * Native ETH uses viem's `ethAddress` sentinel as `token`. `symbol`/`decimals`
+ * are best-effort and may be absent, notably on the `eth_simulateV1` fallback.
+ */
+export interface AssetChange {
+    readonly token: Address;
+    readonly symbol?: string;
+    readonly decimals?: number;
+    /** Signed net change of the account's balance, in raw token units. */
+    readonly diff: bigint;
+}
+/**
+ * Net per-token balance changes for one account over the whole bundle. Returned
+ * for every account that nets a non-zero change, the sender and counterparties
+ * alike (the zero address is kept for mints/burns). Accounts and their `changes`
+ * are sorted by address for deterministic, cross-backend output.
+ *
+ * Native-ETH coverage differs by backend: Tenderly reports the full net ETH
+ * delta (including ETH moved via internal calls), while the `eth_simulateV1`
+ * fallback derives native ETH only from the top-level transaction `value`s —
+ * ETH moved internally (e.g. a `WETH.withdraw` refund) is not captured there.
+ */
+export interface AccountAssetChanges {
+    readonly account: Address;
+    readonly changes: readonly AssetChange[];
+}
 /**
  * A parsed ERC20 / WETH9 transfer extracted from simulation logs. Returned in
  * `SimulationResult.transfers`.
@@ -87,7 +114,10 @@ export interface Transfer {
  * - `simulationTxs` is the full resolved transaction list (including
  *   prepended authorization txs).
  * - `calls[i]` corresponds 1:1 with `simulationTxs[i]` — read raw logs,
- *   status, returnData/gasUsed, and (Tenderly only) assetChanges per tx.
+ *   status, returnData/gasUsed.
+ * - `assetChanges` is the net per-asset balance change over the whole bundle,
+ *   grouped by account (sender and counterparties), normalized to the same
+ *   shape across backends — see `AccountAssetChanges`.
  * - `transfers[k].txIdx` indexes into `simulationTxs` to attribute each
  *   transfer to its emitting transaction.
  */
@@ -96,12 +126,13 @@ export interface SimulationResult {
     readonly simulationTxs: readonly SimulationTransaction[];
     /**
      * Per-transaction normalized output. `calls[i]` corresponds 1:1 with
-     * `simulationTxs[i]`. Use this to read raw logs, status, return data, gas
-     * used, and (Tenderly only) asset changes per transaction.
+     * `simulationTxs[i]`. Use this to read raw logs, status, return data, gas used.
      */
     readonly calls: readonly SimulationCall[];
     /** Parsed ERC-20 / WETH9 transfers from the simulation. */
     readonly transfers: readonly Transfer[];
+    /** Net per-asset balance changes, grouped by account, over the whole bundle. */
+    readonly assetChanges: readonly AccountAssetChanges[];
 }
 /** Minimal structured logger the package calls for warnings and info. */
 export interface SimulationLogger {
@@ -122,10 +153,11 @@ export interface SimulateParams {
 /**
  * Internal raw result from a simulation adapter before normalization.
  * `calls[i]` corresponds 1:1 with the i-th transaction passed to the
- * backend.
+ * backend; `assetChanges` is the bundle-level aggregate grouped by account.
  */
 export interface RawSimulationResult {
     calls: RawCall[];
+    assetChanges: AccountAssetChanges[];
 }
 /**
  * Normalized EVM log emitted by a single simulated call. The shape is the
@@ -149,15 +181,14 @@ export interface RawCall {
     status: boolean;
     returnData: Hex;
     gasUsed: bigint;
-    /** Tenderly-only `assetChanges` payload. Absent on `eth_simulateV1`. */
-    assetChanges?: unknown;
 }
 /**
  * Per-transaction normalized output from the simulation backend.
  *
  * `SimulationResult.calls[i]` corresponds 1:1 with
  * `SimulationResult.simulationTxs[i]`. Use this to read raw logs, status,
- * return data, gas used, and (Tenderly only) asset changes per transaction.
+ * return data, and gas used. Net asset changes are reported at the bundle
+ * level — see `SimulationResult.assetChanges`.
  */
 export interface SimulationCall {
     readonly logs: readonly RawLog[];
@@ -172,9 +203,4 @@ export interface SimulationCall {
     readonly returnData: Hex;
     /** Gas used by this call (root frame). */
     readonly gasUsed: bigint;
-    /**
-     * Tenderly-only `assetChanges` payload for this tx. Opaque `unknown` —
-     * do not destructure without validation. Absent on `eth_simulateV1`.
-     */
-    readonly assetChanges?: unknown;
 }

package/lib/esm/index.d.ts

@@ -1,3 +1,3 @@
 export { BlacklistViolationError, ExternalServiceError, SimulationPackageError, SimulationRevertedError, SimulationValidationError, UnsupportedChainError, } from "./errors.js";
 export { simulate } from "./simulate/index.js";
-export type { ChainSimulationConfig, RawLog, SimulateParams, SimulationAuthorization, SimulationCall, SimulationConfig, SimulationLogger, SimulationResult, SimulationTransaction, TenderlyRpcConfig, Transfer, } from "./types.js";
+export type { AccountAssetChanges, AssetChange, ChainSimulationConfig, RawLog, SimulateParams, SimulationAuthorization, SimulationCall, SimulationConfig, SimulationLogger, SimulationResult, SimulationTransaction, TenderlyRpcConfig, Transfer, } from "./types.js";

package/lib/esm/simulate/asset-changes.d.ts

@@ -0,0 +1,19 @@
+import { type Address } from "viem";
+import type { AccountAssetChanges } from "../types.js";
+/** A single signed contribution to one account's balance for one token. */
+export interface AssetChangeEntry {
+    account: Address;
+    token: Address;
+    diff: bigint;
+    symbol?: string;
+    decimals?: number;
+}
+/**
+ * Net signed per-(account, token) contributions into balance changes grouped by
+ * account. Accounts and their `changes` are sorted by address for deterministic
+ * output; zero-net tokens and accounts are dropped.
+ *
+ * @param entries - Signed contributions; `diff` is added per (account, token).
+ * @returns One {@link AccountAssetChanges} per account with a non-zero change.
+ */
+export declare function groupAssetChanges(entries: AssetChangeEntry[]): AccountAssetChanges[];

package/lib/esm/simulate/asset-changes.js

@@ -0,0 +1,44 @@
+import { getAddress } from "viem";
+// Locale-independent byte-order compare on lowercased hex, matching `sortTransfers`.
+const compareAddress = (a, b) => {
+    const al = a.toLowerCase();
+    const bl = b.toLowerCase();
+    return al < bl ? -1 : al > bl ? 1 : 0;
+};
+/**
+ * Net signed per-(account, token) contributions into balance changes grouped by
+ * account. Accounts and their `changes` are sorted by address for deterministic
+ * output; zero-net tokens and accounts are dropped.
+ *
+ * @param entries - Signed contributions; `diff` is added per (account, token).
+ * @returns One {@link AccountAssetChanges} per account with a non-zero change.
+ */
+export function groupAssetChanges(entries) {
+    const byAccount = new Map();
+    for (const entry of entries) {
+        if (entry.diff === 0n)
+            continue;
+        const account = getAddress(entry.account);
+        // `token` is normalized by callers (checksummed contract or `ethAddress`).
+        const token = entry.token;
+        let tokens = byAccount.get(account);
+        if (!tokens)
+            byAccount.set(account, (tokens = new Map()));
+        const prev = tokens.get(token);
+        tokens.set(token, {
+            token,
+            symbol: prev?.symbol ?? entry.symbol,
+            decimals: prev?.decimals ?? entry.decimals,
+            diff: (prev?.diff ?? 0n) + entry.diff,
+        });
+    }
+    return [...byAccount]
+        .map(([account, tokens]) => ({
+        account,
+        changes: [...tokens.values()]
+            .filter((c) => c.diff !== 0n)
+            .sort((x, y) => compareAddress(x.token, y.token)),
+    }))
+        .filter((a) => a.changes.length > 0)
+        .sort((a, b) => compareAddress(a.account, b.account));
+}

package/lib/esm/simulate/backends/eth-simulate-v1.d.ts

@@ -5,6 +5,15 @@ import type { RawSimulationResult, SimulationTransaction } from "../../types.js"
  *
  * Uses stateOverride to set the user's ETH balance high enough to avoid
  * false "insufficient balance for gas" reverts.
+ *
+ * Derives `assetChanges` (net per-token deltas grouped by account) from the
+ * emitted transfer logs, plus native ETH from each transaction's top-level
+ * `value` (payer debited, recipient credited, under viem's `ethAddress`).
+ *
+ * Coverage on this path is therefore narrower than the Tenderly backend:
+ * native ETH moved through internal calls (e.g. a `WETH.withdraw` refund, a
+ * swap that pays out ETH) emits no log and is not reflected in `value`, so it
+ * is not captured. For full native-ETH accounting use Tenderly.
  */
 export declare function simulateV1(params: {
     rpcUrl: string;

package/lib/esm/simulate/backends/eth-simulate-v1.js

@@ -1,10 +1,21 @@
-import { createPublicClient, getAddress, http, maxUint256, } from "viem";
+import { createPublicClient, ethAddress, getAddress, http, maxUint256, } from "viem";
 import { ExternalServiceError, SimulationRevertedError, SimulationValidationError, } from "../../errors.js";
+import { groupAssetChanges } from "../asset-changes.js";
+import { parseTransfers } from "../parsing/index.js";
 /**
  * Simulate transactions using eth_simulateV1 (viem simulateCalls).
  *
  * Uses stateOverride to set the user's ETH balance high enough to avoid
  * false "insufficient balance for gas" reverts.
+ *
+ * Derives `assetChanges` (net per-token deltas grouped by account) from the
+ * emitted transfer logs, plus native ETH from each transaction's top-level
+ * `value` (payer debited, recipient credited, under viem's `ethAddress`).
+ *
+ * Coverage on this path is therefore narrower than the Tenderly backend:
+ * native ETH moved through internal calls (e.g. a `WETH.withdraw` refund, a
+ * swap that pays out ETH) emits no log and is not reflected in `value`, so it
+ * is not captured. For full native-ETH accounting use Tenderly.
  */
 export async function simulateV1(params) {
     const { rpcUrl, transactions, blockNumber, signal } = params;
@@ -61,7 +72,13 @@ export async function simulateV1(params) {
             returnData: r.data ?? "0x",
             gasUsed: r.gasUsed,
         }));
-        return { calls: rawCalls };
+        return {
+            calls: rawCalls,
+            assetChanges: toAssetChanges({
+                transfers: parseTransfers(rawCalls),
+                transactions,
+            }),
+        };
     }
     catch (error) {
         if (error instanceof SimulationRevertedError)
@@ -71,3 +88,24 @@ export async function simulateV1(params) {
         throw new ExternalServiceError(`eth_simulateV1 error: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
 }
+/**
+ * Reduce parsed transfer logs and top-level transaction values to net per-token
+ * balance changes grouped by account. Native ETH is taken from the top-level
+ * `value`s (payer debited, recipient credited — internal moves are not logged,
+ * see `simulateV1` for the coverage caveat).
+ */
+function toAssetChanges(params) {
+    const { transfers, transactions } = params;
+    const entries = [];
+    for (const tx of transactions) {
+        if (!tx.value)
+            continue;
+        entries.push({ account: tx.from, token: ethAddress, diff: -tx.value });
+        entries.push({ account: tx.to, token: ethAddress, diff: tx.value });
+    }
+    for (const { token, from, to, amount } of transfers) {
+        entries.push({ account: to, token, diff: amount });
+        entries.push({ account: from, token, diff: -amount });
+    }
+    return groupAssetChanges(entries);
+}

package/lib/esm/simulate/backends/tenderly-rpc.js

@@ -1,6 +1,7 @@
-import { isAddress, isHex, maxUint256, numberToHex, } from "viem";
+import { ethAddress, getAddress, isAddress, isHex, maxUint256, numberToHex, } from "viem";
 import { z } from "zod";
 import { ExternalServiceError, SimulationRevertedError, SimulationValidationError, } from "../../errors.js";
+import { groupAssetChanges } from "../asset-changes.js";
 const addressSchema = z.custom((val) => typeof val === "string" && isAddress(val));
 const hexSchema = z.custom((val) => typeof val === "string" && isHex(val));
 const traceFrameSchema = z
@@ -22,13 +23,27 @@ const logSchema = z
         .optional(),
 })
     .passthrough();
+const assetChangeSchema = z
+    .object({
+    assetInfo: z
+        .object({
+        contractAddress: addressSchema.optional(),
+        symbol: z.string().optional(),
+        decimals: z.number().optional(),
+    })
+        .passthrough(),
+    from: addressSchema.optional(),
+    to: addressSchema.optional(),
+    rawAmount: hexSchema,
+})
+    .passthrough();
 const simResultSchema = z
     .object({
     status: z.boolean(),
     gasUsed: hexSchema,
     logs: z.array(logSchema).optional(),
     trace: z.array(traceFrameSchema).optional(),
-    assetChanges: z.unknown().optional(),
+    assetChanges: z.array(assetChangeSchema).optional(),
     error: z.string().optional(),
     errorMessage: z.string().optional(),
 })
@@ -81,7 +96,10 @@ export async function simulateTenderlyRpc(params) {
                 signal,
             });
             const result = unwrapResult(singleEnvelope.parse(json));
-            return { calls: [toRawCall(result)] };
+            return {
+                calls: [toRawCall(result)],
+                assetChanges: toAssetChanges([result]),
+            };
         }
         const json = await rpcRequest({
             rpcUrl: config.rpcUrl,
@@ -89,8 +107,11 @@ export async function simulateTenderlyRpc(params) {
             params: [transactions.map(buildCall), block, stateOverrides],
             signal,
         });
-        const result = unwrapResult(bundleEnvelope.parse(json));
-        return { calls: result.map(toRawCall) };
+        const results = unwrapResult(bundleEnvelope.parse(json));
+        return {
+            calls: results.map(toRawCall),
+            assetChanges: toAssetChanges(results),
+        };
     }
     catch (error) {
         if (error instanceof SimulationRevertedError)
@@ -168,6 +189,39 @@ function toRawCall(data) {
         status: true,
         returnData: data.trace?.[0]?.output ?? "0x",
         gasUsed: BigInt(data.gasUsed),
-        assetChanges: data.assetChanges,
     };
 }
+/**
+ * Reduce Tenderly's per-transfer asset changes to net per-token balance changes
+ * grouped by account. Both endpoints of each transfer are accounted (sender,
+ * counterparties, and the zero address for mints/burns).
+ */
+function toAssetChanges(results) {
+    const entries = [];
+    for (const result of results) {
+        for (const change of result.assetChanges ?? []) {
+            const amount = BigInt(change.rawAmount);
+            const token = change.assetInfo.contractAddress
+                ? getAddress(change.assetInfo.contractAddress)
+                : ethAddress;
+            const { symbol, decimals } = change.assetInfo;
+            if (change.to)
+                entries.push({
+                    account: change.to,
+                    token,
+                    diff: amount,
+                    symbol,
+                    decimals,
+                });
+            if (change.from)
+                entries.push({
+                    account: change.from,
+                    token,
+                    diff: -amount,
+                    symbol,
+                    decimals,
+                });
+        }
+    }
+    return groupAssetChanges(entries);
+}

package/lib/esm/simulate/pipeline/bundler-retention.d.ts

@@ -9,11 +9,11 @@ interface AssertNoBundlerRetentionParams {
  *
  * Uses net flow (inbound minus outbound) per (bundler address, token) pair.
  * Bundler3 legitimately receives tokens as an intermediary (user → bundler3 →
- * vault), so gross inbound would fire false positives. We only flag when
- * `|net| > DUST_THRESHOLD` — catching both **retention** (tokens stuck in
- * bundler, positive net) and **drain** (bundler sending more than it received
- * in this bundle, negative net — which implies a pre-existing or state-override
- * balance is being drawn down, a red flag for pre-broadcast integrity).
+ * vault), so gross inbound would fire false positives. We only block positive
+ * net flow above `DUST_THRESHOLD` — tokens stuck in a bundler address. Negative
+ * net flow means the simulated bundle sweeps a pre-existing or state-overridden
+ * bundler balance. That is useful telemetry, but not current-bundle retention,
+ * so it is warned instead of raising a blacklist violation.
  */
 export declare function assertNoBundlerRetention(params: AssertNoBundlerRetentionParams): void;
 export {};

package/lib/esm/simulate/pipeline/bundler-retention.js

@@ -44,11 +44,11 @@ function getBundlerAddresses(chainId, logger) {
  *
  * Uses net flow (inbound minus outbound) per (bundler address, token) pair.
  * Bundler3 legitimately receives tokens as an intermediary (user → bundler3 →
- * vault), so gross inbound would fire false positives. We only flag when
- * `|net| > DUST_THRESHOLD` — catching both **retention** (tokens stuck in
- * bundler, positive net) and **drain** (bundler sending more than it received
- * in this bundle, negative net — which implies a pre-existing or state-override
- * balance is being drawn down, a red flag for pre-broadcast integrity).
+ * vault), so gross inbound would fire false positives. We only block positive
+ * net flow above `DUST_THRESHOLD` — tokens stuck in a bundler address. Negative
+ * net flow means the simulated bundle sweeps a pre-existing or state-overridden
+ * bundler balance. That is useful telemetry, but not current-bundle retention,
+ * so it is warned instead of raising a blacklist violation.
  */
 export function assertNoBundlerRetention(params) {
     const { chainId, transfers, logger } = params;
@@ -74,15 +74,23 @@ export function assertNoBundlerRetention(params) {
         if (bundlerAddresses.has(t.from))
             recordFlow(t.from, t.token, -t.amount);
     }
-    const flagged = [...flow.values()].filter((e) => absBigInt(e.netChange) > DUST_THRESHOLD);
-    if (flagged.length > 0) {
-        throw new BlacklistViolationError("Simulation detected asset transfers retained or drained by restricted bundler contracts", flagged.map((e) => ({
+    const entries = [...flow.values()];
+    const drained = entries.filter((e) => e.netChange < -DUST_THRESHOLD);
+    if (drained.length > 0) {
+        logger?.warn("Simulation detected pre-existing bundler balance being swept", {
+            changes: drained.map((e) => ({
+                address: e.address,
+                token: e.token,
+                netSwept: (-e.netChange).toString(),
+            })),
+        });
+    }
+    const retained = entries.filter((e) => e.netChange > DUST_THRESHOLD);
+    if (retained.length > 0) {
+        throw new BlacklistViolationError("Simulation detected asset transfers retained by restricted bundler contracts", retained.map((e) => ({
             address: e.address,
             token: e.token,
             netRetained: e.netChange.toString(),
         })));
     }
 }
-function absBigInt(x) {
-    return x < 0n ? -x : x;
-}

package/lib/esm/simulate/simulate.d.ts

@@ -9,8 +9,10 @@ import type { SimulateParams, SimulationConfig, SimulationResult } from "../type
  *
  * - `transfers` → user-facing preview / server-side verification.
  * - `simulationTxs` + `transfers` → server-side verification before broadcast.
- * - `calls[i]` → per-tx raw backend output (`logs`, `status`, `returnData`, `gasUsed`,
- *   and Tenderly-only `assetChanges`). Aligned 1:1 with `simulationTxs[i]`.
+ * - `calls[i]` → per-tx raw backend output (`logs`, `status`, `returnData`, `gasUsed`).
+ *   Aligned 1:1 with `simulationTxs[i]`.
+ * - `assetChanges` → net per-asset balance changes grouped by account (sender and
+ *   counterparties) over the whole bundle, normalized to the same shape across backends.
  * - `transfers[k].txIdx` → index into `simulationTxs` of the tx that emitted the
  *   underlying log; consumers map back via `simulationTxs[transfer.txIdx]`.
  *
@@ -27,15 +29,15 @@ import type { SimulateParams, SimulationConfig, SimulationResult } from "../type
  *   empty transactions, malformed authorizations).
  * @throws {UnsupportedChainError} when the chain is not configured for any backend.
  * @throws {SimulationRevertedError} when the bundle reverts on either backend.
- * @throws {BlacklistViolationError} when the simulation leaves value retained by or
- *   drained from a `bundler3` address beyond the dust threshold.
+ * @throws {BlacklistViolationError} when the simulation leaves value retained by
+ *   a `bundler3` address beyond the dust threshold.
  * @throws {ExternalServiceError} (a) when both backends are unavailable within the
  *   timeout budget, or (b) when a backend returns a `calls` array whose length does
  *   not match the resolved `simulationTxs` — refusing to map transfers with mismatched
  *   per-tx output.
  * @returns A {@link SimulationResult} carrying the resolved `simulationTxs`, per-tx
- *   `calls` (aligned 1:1 with `simulationTxs`), and parsed `transfers` (each stamped
- *   with `txIdx`).
+ *   `calls` (aligned 1:1 with `simulationTxs`), parsed `transfers` (each stamped
+ *   with `txIdx`), and per-account net `assetChanges`.
  * @example
  * ```ts
  * import { simulate } from "@morpho-org/evm-simulation";

package/lib/esm/simulate/simulate.js

@@ -11,8 +11,10 @@ import { assertNoBundlerRetention, buildSimulationTxs, executeSimulation, valida
  *
  * - `transfers` → user-facing preview / server-side verification.
  * - `simulationTxs` + `transfers` → server-side verification before broadcast.
- * - `calls[i]` → per-tx raw backend output (`logs`, `status`, `returnData`, `gasUsed`,
- *   and Tenderly-only `assetChanges`). Aligned 1:1 with `simulationTxs[i]`.
+ * - `calls[i]` → per-tx raw backend output (`logs`, `status`, `returnData`, `gasUsed`).
+ *   Aligned 1:1 with `simulationTxs[i]`.
+ * - `assetChanges` → net per-asset balance changes grouped by account (sender and
+ *   counterparties) over the whole bundle, normalized to the same shape across backends.
  * - `transfers[k].txIdx` → index into `simulationTxs` of the tx that emitted the
  *   underlying log; consumers map back via `simulationTxs[transfer.txIdx]`.
  *
@@ -29,15 +31,15 @@ import { assertNoBundlerRetention, buildSimulationTxs, executeSimulation, valida
  *   empty transactions, malformed authorizations).
  * @throws {UnsupportedChainError} when the chain is not configured for any backend.
  * @throws {SimulationRevertedError} when the bundle reverts on either backend.
- * @throws {BlacklistViolationError} when the simulation leaves value retained by or
- *   drained from a `bundler3` address beyond the dust threshold.
+ * @throws {BlacklistViolationError} when the simulation leaves value retained by
+ *   a `bundler3` address beyond the dust threshold.
  * @throws {ExternalServiceError} (a) when both backends are unavailable within the
  *   timeout budget, or (b) when a backend returns a `calls` array whose length does
  *   not match the resolved `simulationTxs` — refusing to map transfers with mismatched
  *   per-tx output.
  * @returns A {@link SimulationResult} carrying the resolved `simulationTxs`, per-tx
- *   `calls` (aligned 1:1 with `simulationTxs`), and parsed `transfers` (each stamped
- *   with `txIdx`).
+ *   `calls` (aligned 1:1 with `simulationTxs`), parsed `transfers` (each stamped
+ *   with `txIdx`), and per-account net `assetChanges`.
  * @example
  * ```ts
  * import { simulate } from "@morpho-org/evm-simulation";
@@ -81,5 +83,6 @@ export async function simulate(config, params) {
         simulationTxs,
         calls: result.calls,
         transfers,
+        assetChanges: result.assetChanges,
     };
 }

package/lib/esm/types.d.ts

@@ -64,6 +64,33 @@ export type SimulationAuthorization = {
     /** Defaults to maxUint256. Caller can set explicit amount for tokens that don't support max approval. */
     amount?: bigint;
 };
+/**
+ * Net balance change for a single asset (one token) within an account's entry.
+ * Native ETH uses viem's `ethAddress` sentinel as `token`. `symbol`/`decimals`
+ * are best-effort and may be absent, notably on the `eth_simulateV1` fallback.
+ */
+export interface AssetChange {
+    readonly token: Address;
+    readonly symbol?: string;
+    readonly decimals?: number;
+    /** Signed net change of the account's balance, in raw token units. */
+    readonly diff: bigint;
+}
+/**
+ * Net per-token balance changes for one account over the whole bundle. Returned
+ * for every account that nets a non-zero change, the sender and counterparties
+ * alike (the zero address is kept for mints/burns). Accounts and their `changes`
+ * are sorted by address for deterministic, cross-backend output.
+ *
+ * Native-ETH coverage differs by backend: Tenderly reports the full net ETH
+ * delta (including ETH moved via internal calls), while the `eth_simulateV1`
+ * fallback derives native ETH only from the top-level transaction `value`s —
+ * ETH moved internally (e.g. a `WETH.withdraw` refund) is not captured there.
+ */
+export interface AccountAssetChanges {
+    readonly account: Address;
+    readonly changes: readonly AssetChange[];
+}
 /**
  * A parsed ERC20 / WETH9 transfer extracted from simulation logs. Returned in
  * `SimulationResult.transfers`.
@@ -87,7 +114,10 @@ export interface Transfer {
  * - `simulationTxs` is the full resolved transaction list (including
  *   prepended authorization txs).
  * - `calls[i]` corresponds 1:1 with `simulationTxs[i]` — read raw logs,
- *   status, returnData/gasUsed, and (Tenderly only) assetChanges per tx.
+ *   status, returnData/gasUsed.
+ * - `assetChanges` is the net per-asset balance change over the whole bundle,
+ *   grouped by account (sender and counterparties), normalized to the same
+ *   shape across backends — see `AccountAssetChanges`.
  * - `transfers[k].txIdx` indexes into `simulationTxs` to attribute each
  *   transfer to its emitting transaction.
  */
@@ -96,12 +126,13 @@ export interface SimulationResult {
     readonly simulationTxs: readonly SimulationTransaction[];
     /**
      * Per-transaction normalized output. `calls[i]` corresponds 1:1 with
-     * `simulationTxs[i]`. Use this to read raw logs, status, return data, gas
-     * used, and (Tenderly only) asset changes per transaction.
+     * `simulationTxs[i]`. Use this to read raw logs, status, return data, gas used.
      */
     readonly calls: readonly SimulationCall[];
     /** Parsed ERC-20 / WETH9 transfers from the simulation. */
     readonly transfers: readonly Transfer[];
+    /** Net per-asset balance changes, grouped by account, over the whole bundle. */
+    readonly assetChanges: readonly AccountAssetChanges[];
 }
 /** Minimal structured logger the package calls for warnings and info. */
 export interface SimulationLogger {
@@ -122,10 +153,11 @@ export interface SimulateParams {
 /**
  * Internal raw result from a simulation adapter before normalization.
  * `calls[i]` corresponds 1:1 with the i-th transaction passed to the
- * backend.
+ * backend; `assetChanges` is the bundle-level aggregate grouped by account.
  */
 export interface RawSimulationResult {
     calls: RawCall[];
+    assetChanges: AccountAssetChanges[];
 }
 /**
  * Normalized EVM log emitted by a single simulated call. The shape is the
@@ -149,15 +181,14 @@ export interface RawCall {
     status: boolean;
     returnData: Hex;
     gasUsed: bigint;
-    /** Tenderly-only `assetChanges` payload. Absent on `eth_simulateV1`. */
-    assetChanges?: unknown;
 }
 /**
  * Per-transaction normalized output from the simulation backend.
  *
  * `SimulationResult.calls[i]` corresponds 1:1 with
  * `SimulationResult.simulationTxs[i]`. Use this to read raw logs, status,
- * return data, gas used, and (Tenderly only) asset changes per transaction.
+ * return data, and gas used. Net asset changes are reported at the bundle
+ * level — see `SimulationResult.assetChanges`.
  */
 export interface SimulationCall {
     readonly logs: readonly RawLog[];
@@ -172,9 +203,4 @@ export interface SimulationCall {
     readonly returnData: Hex;
     /** Gas used by this call (root frame). */
     readonly gasUsed: bigint;
-    /**
-     * Tenderly-only `assetChanges` payload for this tx. Opaque `unknown` —
-     * do not destructure without validation. Absent on `eth_simulateV1`.
-     */
-    readonly assetChanges?: unknown;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@morpho-org/evm-simulation",
   "description": "EVM simulation engine for Morpho transactions.",
-  "version": "3.0.0",
+  "version": "4.0.1",
   "author": "Morpho Association <contact@morpho.org>",
   "contributors": [
     "Rubilmax <rmilon@gmail.com>"
@@ -25,23 +25,25 @@
   ],
   "dependencies": {
     "zod": "^4.4.3",
-    "@morpho-org/blue-sdk": "^6.1.0",
-    "@morpho-org/morpho-ts": "^2.6.0"
+    "@morpho-org/morpho-ts": "^2.6.0",
+    "@morpho-org/blue-sdk": "^6.2.0"
   },
   "peerDependencies": {
     "viem": "^2.0.0"
   },
   "devDependencies": {
     "typescript": "^6.0.3",
-    "viem": "^2.50.4",
-    "vitest": "^4.1.7"
+    "viem": "2.52.2",
+    "vitest": "^4.1.8",
+    "@morpho-org/test": "^2.8.1"
   },
   "scripts": {
     "prepublish": "$npm_execpath build",
     "build": "tsc --noEmit && $npm_execpath build:cjs && $npm_execpath build:esm",
     "build:cjs": "tsc --build tsconfig.build.cjs.json && echo '{\"type\":\"commonjs\"}' > lib/cjs/package.json",
     "build:esm": "tsc --build tsconfig.build.esm.json && echo '{\"type\":\"module\"}' > lib/esm/package.json",
-    "test": "vitest --root ../.. --project evm-simulation"
+    "test": "vitest --root ../.. --project evm-simulation",
+    "test:fork": "dotenv -- vitest --root ../.. --project evm-simulation-fork"
   },
   "exports": {
     ".": {

package/src/index.ts

@@ -12,6 +12,8 @@ export {
 export { simulate } from "./simulate/index.js";
 // Types
 export type {
+  AccountAssetChanges,
+  AssetChange,
   ChainSimulationConfig,
   RawLog,
   SimulateParams,