@morpho-org/evm-simulation 2.0.2 → 4.0.0

package/lib/esm/simulate/backends/index.js

@@ -1,2 +1,2 @@
 export { simulateV1 } from "./eth-simulate-v1.js";
-export { simulateTenderlyRest } from "./tenderly-rest.js";
+export { simulateTenderlyRpc } from "./tenderly-rpc.js";

package/lib/esm/simulate/backends/tenderly-rpc.d.ts

@@ -0,0 +1,23 @@
+import { type BlockTag } from "viem";
+import type { RawSimulationResult, SimulationTransaction, TenderlyRpcConfig } from "../../types.js";
+/**
+ * Simulate one or more transactions via Tenderly's Node Web3 Gateway.
+ * Dispatches to `tenderly_simulateTransaction` for a single call and
+ * `tenderly_simulateBundle` for a multi-call bundle.
+ *
+ * @param params.config - Tenderly RPC config (URL with access key embedded).
+ * @param params.transactions - Bundle to simulate, in execution order.
+ * @param params.blockNumber - Optional pinned block number or `BlockTag`. Defaults to `latest`.
+ * @param params.signal - Optional `AbortSignal` for cancellation / timeout.
+ * @returns A {@link RawSimulationResult} with one `RawCall` per input transaction.
+ * @throws {SimulationValidationError} when `transactions` is empty.
+ * @throws {SimulationRevertedError} when any simulated tx reports `status: false`.
+ * @throws {ExternalServiceError} on non-2xx response, JSON-RPC envelope error,
+ *   schema-validation failure, or fetch-layer failure.
+ */
+export declare function simulateTenderlyRpc(params: {
+    config: TenderlyRpcConfig;
+    transactions: SimulationTransaction[];
+    blockNumber?: bigint | BlockTag;
+    signal?: AbortSignal;
+}): Promise<RawSimulationResult>;

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

@@ -0,0 +1,227 @@
+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
+    .object({
+    output: hexSchema.optional(),
+    error: z.string().optional(),
+    errorReason: z.string().optional(),
+})
+    .passthrough();
+const logSchema = z
+    .object({
+    raw: z
+        .object({
+        address: addressSchema,
+        topics: z.array(hexSchema).optional(),
+        data: hexSchema.optional(),
+    })
+        .passthrough()
+        .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.array(assetChangeSchema).optional(),
+    error: z.string().optional(),
+    errorMessage: z.string().optional(),
+})
+    .passthrough();
+const rpcErrorSchema = z
+    .object({
+    code: z.number().optional(),
+    message: z.string(),
+    data: z.unknown().optional(),
+})
+    .passthrough();
+function rpcEnvelope(result) {
+    return z
+        .object({ result: result.optional(), error: rpcErrorSchema.optional() })
+        .passthrough();
+}
+const singleEnvelope = rpcEnvelope(simResultSchema);
+const bundleEnvelope = rpcEnvelope(z.array(simResultSchema).min(1));
+/**
+ * Simulate one or more transactions via Tenderly's Node Web3 Gateway.
+ * Dispatches to `tenderly_simulateTransaction` for a single call and
+ * `tenderly_simulateBundle` for a multi-call bundle.
+ *
+ * @param params.config - Tenderly RPC config (URL with access key embedded).
+ * @param params.transactions - Bundle to simulate, in execution order.
+ * @param params.blockNumber - Optional pinned block number or `BlockTag`. Defaults to `latest`.
+ * @param params.signal - Optional `AbortSignal` for cancellation / timeout.
+ * @returns A {@link RawSimulationResult} with one `RawCall` per input transaction.
+ * @throws {SimulationValidationError} when `transactions` is empty.
+ * @throws {SimulationRevertedError} when any simulated tx reports `status: false`.
+ * @throws {ExternalServiceError} on non-2xx response, JSON-RPC envelope error,
+ *   schema-validation failure, or fetch-layer failure.
+ */
+export async function simulateTenderlyRpc(params) {
+    const { config, transactions, blockNumber, signal } = params;
+    const firstTx = transactions[0];
+    if (!firstTx) {
+        throw new SimulationValidationError("At least one transaction is required", []);
+    }
+    const block = encodeBlock(blockNumber);
+    // Inflate sender ETH balance to avoid false "insufficient funds for gas"
+    // reverts on wallets low on native gas token — mirrors simulateV1.
+    const stateOverrides = buildStateOverrides(firstTx.from);
+    try {
+        if (transactions.length === 1) {
+            const json = await rpcRequest({
+                rpcUrl: config.rpcUrl,
+                method: "tenderly_simulateTransaction",
+                params: [buildCall(firstTx), block, stateOverrides],
+                signal,
+            });
+            const result = unwrapResult(singleEnvelope.parse(json));
+            return {
+                calls: [toRawCall(result)],
+                assetChanges: toAssetChanges([result]),
+            };
+        }
+        const json = await rpcRequest({
+            rpcUrl: config.rpcUrl,
+            method: "tenderly_simulateBundle",
+            params: [transactions.map(buildCall), block, stateOverrides],
+            signal,
+        });
+        const results = unwrapResult(bundleEnvelope.parse(json));
+        return {
+            calls: results.map(toRawCall),
+            assetChanges: toAssetChanges(results),
+        };
+    }
+    catch (error) {
+        if (error instanceof SimulationRevertedError)
+            throw error;
+        if (error instanceof ExternalServiceError)
+            throw error;
+        throw new ExternalServiceError(`Tenderly RPC error: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+}
+async function rpcRequest(params) {
+    const { rpcUrl, method, params: rpcParams, signal } = params;
+    const response = await fetch(rpcUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params: rpcParams }),
+        signal,
+    });
+    if (!response.ok) {
+        throw new ExternalServiceError(`Tenderly RPC returned ${response.status}: ${response.statusText}`);
+    }
+    return await response.json();
+}
+function unwrapResult(envelope) {
+    if (envelope.error) {
+        throw new ExternalServiceError(`Tenderly RPC error: ${envelope.error.message}`);
+    }
+    if (envelope.result === undefined) {
+        throw new ExternalServiceError("Tenderly RPC returned no result");
+    }
+    return envelope.result;
+}
+function buildCall(tx) {
+    return {
+        from: tx.from,
+        to: tx.to,
+        input: tx.data,
+        data: tx.data,
+        value: numberToHex(tx.value ?? 0n),
+    };
+}
+function buildStateOverrides(sender) {
+    return { [sender]: { balance: numberToHex(maxUint256) } };
+}
+function encodeBlock(blockNumber) {
+    if (blockNumber === undefined)
+        return "latest";
+    return typeof blockNumber === "bigint"
+        ? numberToHex(blockNumber)
+        : blockNumber;
+}
+function toRawCall(data) {
+    if (data.status !== true) {
+        // Tenderly RPC surfaces the revert reason on the trace frame; the
+        // top-level fields are checked as a defensive fallback.
+        const traceError = data.trace?.find((f) => f.errorReason || f.error);
+        const message = traceError?.errorReason ||
+            traceError?.error ||
+            data.errorMessage ||
+            data.error ||
+            "Transaction simulation reverted";
+        throw new SimulationRevertedError(message, data);
+    }
+    const logs = [];
+    for (const log of data.logs ?? []) {
+        if (log.raw) {
+            logs.push({
+                address: log.raw.address,
+                topics: log.raw.topics ?? [],
+                data: log.raw.data ?? "0x",
+            });
+        }
+    }
+    return {
+        logs,
+        status: true,
+        returnData: data.trace?.[0]?.output ?? "0x",
+        gasUsed: BigInt(data.gasUsed),
+    };
+}
+/**
+ * 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/parsing/transfers.js

@@ -141,7 +141,9 @@ export function parseTransfers(calls, logger) {
             catch (error) {
                 // Safety net for anything that slips past the length checks above
                 // (e.g., viem checksum throws on non-hex input). Loud enough to diagnose.
-                warnMalformed(logger, log, error instanceof Error ? error.message : String(error));
+                warnMalformed(logger, log, 
+                /* v8 ignore next: parser paths throw Error instances for valid RawLog shapes. */
+                error instanceof Error ? error.message : String(error));
             }
         }
     }

package/lib/esm/simulate/pipeline/execute-simulation.d.ts

@@ -5,21 +5,17 @@ import type { RawSimulationResult, SimulationConfig, SimulationTransaction } fro
  *
  * Dispatches the transaction bundle to the available backend with a shared timeout
  * budget:
- * - If Tenderly is configured for the chain, it gets `TENDERLY_BUDGET_RATIO` (60%) of
- *   the timeout. On `ExternalServiceError`, falls back to `eth_simulateV1` with
- *   `max(remaining, FALLBACK_MIN_BUDGET_MS)` so the fallback still has a viable
- *   window when Tenderly eats its full slice. `SimulationRevertedError` (contract
- *   revert) propagates immediately without retry — a revert is a property of the
- *   bundle, not the backend.
+ * - If a Tenderly RPC URL is configured for the chain, it gets
+ *   `TENDERLY_BUDGET_RATIO` (60%) of the timeout. On `ExternalServiceError`,
+ *   falls back to `eth_simulateV1` with `max(remaining, FALLBACK_MIN_BUDGET_MS)`
+ *   so the fallback still has a viable window when Tenderly eats its full slice.
+ *   `SimulationRevertedError` (contract revert) propagates immediately without
+ *   retry — a revert is a property of the bundle, not the backend.
  * - If only `eth_simulateV1` is configured, it gets the full timeout.
- *
- * `shareable` is Tenderly-only: when true, the backend persists the simulation and
- * returns a shareable URL. `eth_simulateV1` ignores it (no persistence concept).
  */
 export declare function executeSimulation(params: {
     config: SimulationConfig;
     chainId: number;
     transactions: SimulationTransaction[];
     blockNumber?: bigint | BlockTag;
-    shareable: boolean;
 }): Promise<RawSimulationResult>;

package/lib/esm/simulate/pipeline/execute-simulation.js

@@ -1,5 +1,5 @@
 import { ExternalServiceError, UnsupportedChainError } from "../../errors.js";
-import { simulateTenderlyRest, simulateV1 } from "../backends/index.js";
+import { simulateTenderlyRpc, simulateV1 } from "../backends/index.js";
 import { resolveChain } from "./resolve-chain.js";
 /** Total budget for a single `simulate()` call across both backends. */
 const DEFAULT_TIMEOUT_MS = 5000;
@@ -20,33 +20,27 @@ const FALLBACK_MIN_BUDGET_MS = 1500;
  *
  * Dispatches the transaction bundle to the available backend with a shared timeout
  * budget:
- * - If Tenderly is configured for the chain, it gets `TENDERLY_BUDGET_RATIO` (60%) of
- *   the timeout. On `ExternalServiceError`, falls back to `eth_simulateV1` with
- *   `max(remaining, FALLBACK_MIN_BUDGET_MS)` so the fallback still has a viable
- *   window when Tenderly eats its full slice. `SimulationRevertedError` (contract
- *   revert) propagates immediately without retry — a revert is a property of the
- *   bundle, not the backend.
+ * - If a Tenderly RPC URL is configured for the chain, it gets
+ *   `TENDERLY_BUDGET_RATIO` (60%) of the timeout. On `ExternalServiceError`,
+ *   falls back to `eth_simulateV1` with `max(remaining, FALLBACK_MIN_BUDGET_MS)`
+ *   so the fallback still has a viable window when Tenderly eats its full slice.
+ *   `SimulationRevertedError` (contract revert) propagates immediately without
+ *   retry — a revert is a property of the bundle, not the backend.
  * - If only `eth_simulateV1` is configured, it gets the full timeout.
- *
- * `shareable` is Tenderly-only: when true, the backend persists the simulation and
- * returns a shareable URL. `eth_simulateV1` ignores it (no persistence concept).
  */
 export async function executeSimulation(params) {
-    const { config, chainId, transactions, blockNumber, shareable } = params;
+    const { config, chainId, transactions, blockNumber } = params;
     const chain = resolveChain(config, chainId);
     const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const deadline = Date.now() + timeoutMs;
-    if (chain.tenderlySupported && config.tenderlyRest) {
+    if (chain.tenderlyRpc) {
         const tenderlyTimeout = Math.floor(timeoutMs * TENDERLY_BUDGET_RATIO);
         try {
-            return await simulateTenderlyRest({
-                config: config.tenderlyRest,
-                chainId,
+            return await simulateTenderlyRpc({
+                config: chain.tenderlyRpc,
                 transactions,
                 blockNumber,
-                shareable,
                 signal: AbortSignal.timeout(tenderlyTimeout),
-                logger: config.logger,
             });
         }
         catch (error) {
@@ -59,8 +53,6 @@ export async function executeSimulation(params) {
             });
             if (!chain.simulateV1Url)
                 throw error;
-            // Give the fallback a reasonable minimum even if Tenderly consumed the
-            // whole budget — otherwise slow-Tenderly == total outage.
             const fallbackBudget = Math.max(deadline - Date.now(), FALLBACK_MIN_BUDGET_MS);
             return await simulateV1({
                 rpcUrl: chain.simulateV1Url,
@@ -71,6 +63,7 @@ export async function executeSimulation(params) {
             });
         }
     }
+    /* v8 ignore next: resolveChain rejects this state before executeSimulation reaches the fallback path. */
     if (!chain.simulateV1Url) {
         throw new UnsupportedChainError(chainId);
     }

package/lib/esm/simulate/pipeline/resolve-chain.d.ts

@@ -1,14 +1,15 @@
-import type { SimulationConfig } from "../../types.js";
+import type { SimulationConfig, TenderlyRpcConfig } from "../../types.js";
 interface ChainCapability {
-    tenderlySupported: boolean;
+    tenderlyRpc?: TenderlyRpcConfig;
     simulateV1Url?: string;
 }
 /**
  * Stage 2 of the simulate() pipeline.
  *
- * Determines which backend(s) are available for a chainId. Throws
- * `UnsupportedChainError` when neither Tenderly nor `eth_simulateV1` is reachable
- * for the requested chain.
+ * Looks up the per-chain `ChainSimulationConfig` and exposes whichever
+ * backends were configured. Throws `UnsupportedChainError` when the chain is
+ * absent from the map or has neither backend wired (defensive — the type
+ * already enforces at least one at construction).
  */
 export declare function resolveChain(config: SimulationConfig, chainId: number): ChainCapability;
 export {};

package/lib/esm/simulate/pipeline/resolve-chain.js

@@ -2,15 +2,18 @@ import { UnsupportedChainError } from "../../errors.js";
 /**
  * Stage 2 of the simulate() pipeline.
  *
- * Determines which backend(s) are available for a chainId. Throws
- * `UnsupportedChainError` when neither Tenderly nor `eth_simulateV1` is reachable
- * for the requested chain.
+ * Looks up the per-chain `ChainSimulationConfig` and exposes whichever
+ * backends were configured. Throws `UnsupportedChainError` when the chain is
+ * absent from the map or has neither backend wired (defensive — the type
+ * already enforces at least one at construction).
  */
 export function resolveChain(config, chainId) {
-    const tenderlySupported = config.tenderlyRest?.supportedChainIds.has(chainId) ?? false;
-    const simulateV1Url = config.chains.get(chainId)?.simulateV1Url;
-    if (!tenderlySupported && !simulateV1Url) {
+    const entry = config.chains.get(chainId);
+    if (!entry || (!entry.tenderlyRpc && !entry.simulateV1Url)) {
         throw new UnsupportedChainError(chainId);
     }
-    return { tenderlySupported, simulateV1Url };
+    return {
+        tenderlyRpc: entry.tenderlyRpc,
+        simulateV1Url: entry.simulateV1Url,
+    };
 }

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

@@ -3,20 +3,21 @@ import type { SimulateParams, SimulationConfig, SimulationResult } from "../type
  * Simulate a bundle of EVM transactions.
  *
  * Validates input → resolves authorizations into prepended approve txs → runs the bundle
- * through Tenderly REST (primary) or `eth_simulateV1` (fallback) with a shared timeout
+ * through Tenderly RPC (primary) or `eth_simulateV1` (fallback) with a shared timeout
  * budget → parses ERC20/WETH transfers from per-tx logs → asserts no funds are retained
  * by `bundler3` → returns the full result set. The caller reads whichever fields they need:
  *
- * - `transfers` + `tenderlyUrl` → user-facing preview.
- * - `simulationTxs` + `transfers` → server-side verification before broadcast, then pass
- *   both to `screenAddresses` for compliance.
- * - `calls[i]` → per-tx raw backend output (`logs`, `status`, `returnData`, `gasUsed`,
- *   and Tenderly-only `assetChanges`). Aligned 1:1 with `simulationTxs[i]`.
+ * - `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`).
+ *   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]`.
  *
- * @param config - Backend configuration: Tenderly credentials, per-chain RPC URLs, optional
- *   logger, and the overall timeout budget.
+ * @param config - Backend configuration: per-chain Tenderly RPC and/or `eth_simulateV1`
+ *   URL, optional logger, and the overall timeout budget.
  * @param params - Per-call simulation input.
  * @param params.chainId - Chain id the bundle targets.
  * @param params.transactions - The bundle's transactions, in execution order. All must share the
@@ -24,10 +25,6 @@ import type { SimulateParams, SimulationConfig, SimulationResult } from "../type
  * @param params.authorizations - Optional token authorizations resolved into prepended approve
  *   transactions before the main bundle runs.
  * @param params.blockNumber - Optional pinned block number or `BlockTag`. Defaults to `latest`.
- * @param options - Per-call simulation options.
- * @param options.shareable - When `true`, persists the simulation in Tenderly and returns a
- *   shareable `tenderlyUrl`. Honored only on the Tenderly backend, not on the `eth_simulateV1`
- *   fallback. Defaults to `false`.
  * @throws {SimulationValidationError} for invalid input (mixed senders, bad addresses,
  *   empty transactions, malformed authorizations).
  * @throws {UnsupportedChainError} when the chain is not configured for any backend.
@@ -39,14 +36,21 @@ import type { SimulateParams, SimulationConfig, SimulationResult } from "../type
  *   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`), parsed `transfers` (each stamped with
- *   `txIdx`), and the optional `tenderlyUrl`.
+ *   `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";
  *
  * const result = await simulate(
- *   { chains: new Map([[1, { simulateV1Url: rpcUrl }]]) },
+ *   {
+ *     chains: new Map([
+ *       [1, {
+ *         tenderlyRpc: { rpcUrl: process.env.TENDERLY_RPC_URL! },
+ *         simulateV1Url: process.env.MAINNET_RPC_URL,
+ *       }],
+ *     ]),
+ *   },
  *   {
  *     chainId: 1,
  *     transactions: [{ from: user, to: vaultAddress, data: encodedCalldata, value: 0n }],
@@ -55,11 +59,4 @@ import type { SimulateParams, SimulationConfig, SimulationResult } from "../type
  * // result satisfies SimulationResult
  * ```
  */
-export declare function simulate(config: SimulationConfig, params: SimulateParams, options?: {
-    /**
-     * When true, persist the simulation in Tenderly and return a shareable
-     * `tenderlyUrl` in the result. Only honored when the Tenderly backend runs
-     * (not the `eth_simulateV1` fallback). Defaults to `false`.
-     */
-    shareable?: boolean;
-}): Promise<SimulationResult>;
+export declare function simulate(config: SimulationConfig, params: SimulateParams): Promise<SimulationResult>;

package/lib/esm/simulate/simulate.js

@@ -5,20 +5,21 @@ import { assertNoBundlerRetention, buildSimulationTxs, executeSimulation, valida
  * Simulate a bundle of EVM transactions.
  *
  * Validates input → resolves authorizations into prepended approve txs → runs the bundle
- * through Tenderly REST (primary) or `eth_simulateV1` (fallback) with a shared timeout
+ * through Tenderly RPC (primary) or `eth_simulateV1` (fallback) with a shared timeout
  * budget → parses ERC20/WETH transfers from per-tx logs → asserts no funds are retained
  * by `bundler3` → returns the full result set. The caller reads whichever fields they need:
  *
- * - `transfers` + `tenderlyUrl` → user-facing preview.
- * - `simulationTxs` + `transfers` → server-side verification before broadcast, then pass
- *   both to `screenAddresses` for compliance.
- * - `calls[i]` → per-tx raw backend output (`logs`, `status`, `returnData`, `gasUsed`,
- *   and Tenderly-only `assetChanges`). Aligned 1:1 with `simulationTxs[i]`.
+ * - `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`).
+ *   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]`.
  *
- * @param config - Backend configuration: Tenderly credentials, per-chain RPC URLs, optional
- *   logger, and the overall timeout budget.
+ * @param config - Backend configuration: per-chain Tenderly RPC and/or `eth_simulateV1`
+ *   URL, optional logger, and the overall timeout budget.
  * @param params - Per-call simulation input.
  * @param params.chainId - Chain id the bundle targets.
  * @param params.transactions - The bundle's transactions, in execution order. All must share the
@@ -26,10 +27,6 @@ import { assertNoBundlerRetention, buildSimulationTxs, executeSimulation, valida
  * @param params.authorizations - Optional token authorizations resolved into prepended approve
  *   transactions before the main bundle runs.
  * @param params.blockNumber - Optional pinned block number or `BlockTag`. Defaults to `latest`.
- * @param options - Per-call simulation options.
- * @param options.shareable - When `true`, persists the simulation in Tenderly and returns a
- *   shareable `tenderlyUrl`. Honored only on the Tenderly backend, not on the `eth_simulateV1`
- *   fallback. Defaults to `false`.
  * @throws {SimulationValidationError} for invalid input (mixed senders, bad addresses,
  *   empty transactions, malformed authorizations).
  * @throws {UnsupportedChainError} when the chain is not configured for any backend.
@@ -41,14 +38,21 @@ import { assertNoBundlerRetention, buildSimulationTxs, executeSimulation, valida
  *   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`), parsed `transfers` (each stamped with
- *   `txIdx`), and the optional `tenderlyUrl`.
+ *   `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";
  *
  * const result = await simulate(
- *   { chains: new Map([[1, { simulateV1Url: rpcUrl }]]) },
+ *   {
+ *     chains: new Map([
+ *       [1, {
+ *         tenderlyRpc: { rpcUrl: process.env.TENDERLY_RPC_URL! },
+ *         simulateV1Url: process.env.MAINNET_RPC_URL,
+ *       }],
+ *     ]),
+ *   },
  *   {
  *     chainId: 1,
  *     transactions: [{ from: user, to: vaultAddress, data: encodedCalldata, value: 0n }],
@@ -57,9 +61,7 @@ import { assertNoBundlerRetention, buildSimulationTxs, executeSimulation, valida
  * // result satisfies SimulationResult
  * ```
  */
-// biome-ignore lint/complexity/useMaxParams: TODO refactor to ≤2 params
-export async function simulate(config, params, options = {}) {
-    const { shareable = false } = options;
+export async function simulate(config, params) {
     validateInput(params);
     const simulationTxs = buildSimulationTxs(params);
     const result = await executeSimulation({
@@ -67,7 +69,6 @@ export async function simulate(config, params, options = {}) {
         chainId: params.chainId,
         transactions: simulationTxs,
         blockNumber: params.blockNumber,
-        shareable,
     });
     if (result.calls.length !== simulationTxs.length) {
         throw new ExternalServiceError(`Backend returned ${result.calls.length} call result(s) for ${simulationTxs.length} transaction(s) — refusing to map transfers with mismatched lengths`);
@@ -82,6 +83,6 @@ export async function simulate(config, params, options = {}) {
         simulationTxs,
         calls: result.calls,
         transfers,
-        tenderlyUrl: result.tenderlyUrl,
+        assetChanges: result.assetChanges,
     };
 }