@morpho-org/evm-simulation 2.0.2 → 3.0.0

package/README.md

@@ -2,8 +2,8 @@
 
 ## Overview
 
-EVM transaction simulation engine for Morpho — bundle execution preview,
-transfer parsing, and compliance screening.
+EVM transaction simulation engine for Morpho — bundle execution preview
+and transfer parsing.
 
 ## Installation
 
@@ -22,38 +22,29 @@ Add to the consuming app's `package.json`:
 ```ts
 import {
   simulate,
-  screenAddresses,
   type SimulationConfig,
   SimulationRevertedError
 } from "@morpho-org/evm-simulation";
 
 const config: SimulationConfig = {
-  tenderlyRest: {
-    apiBaseUrl: "https://api.tenderly.co",
-    accessToken: process.env.TENDERLY_ACCESS_TOKEN!,
-    accountSlug: "my-account",
-    projectSlug: "my-project",
-    supportedChainIds: new Set([1]),
-  },
-  chains: new Map([[1, { simulateV1Url: process.env.MAINNET_RPC_URL }]]),
+  chains: new Map([
+    [
+      1,
+      {
+        tenderlyRpc: { rpcUrl: process.env.TENDERLY_RPC_URL! },
+        simulateV1Url: process.env.MAINNET_RPC_URL,
+      },
+    ],
+  ]),
   timeoutMs: 5000,
 };
 
 try {
-  // Pass { shareable: true } when you want a shareable Tenderly URL (user-facing preview).
-  // Omit it for server-side verification — the same function, same return shape.
-  const { transfers, simulationTxs, tenderlyUrl } = await simulate(
-    config,
-    {
-      chainId: 1,
-      transactions: [{ from: user, to: vault, data: encodedDeposit }],
-      authorizations: [{ type: "signature", token: usdc, spender: vault }],
-    },
-    { shareable: true }
-  );
-
-  // For server-side flows, pipe into screenAddresses:
-  await screenAddresses({ simulationTxs, transfers });
+  const { transfers, simulationTxs } = await simulate(config, {
+    chainId: 1,
+    transactions: [{ from: user, to: vault, data: encodedDeposit }],
+    authorizations: [{ type: "signature", token: usdc, spender: vault }],
+  });
 } catch (err) {
   if (err instanceof SimulationRevertedError) {
     // show err.reason to the user
@@ -62,20 +53,21 @@ try {
 }
 ```
 
+Each chain entry must declare at least one backend — `tenderlyRpc` (primary), `simulateV1Url` (fallback), or both. The type system enforces this.
+
 ### API surface
 
 All symbols below are re-exported from the package root.
 
-- `simulate(config, params, options?)` — run a bundle through the simulation pipeline. Pass `{ shareable: true }` for a shareable Tenderly URL; omit for server-side verification.
-- `screenAddresses({ simulationTxs, transfers, chainalysisApiKey? })` — static sanctioned-set + optional Chainalysis screening.
-- Config types: `SimulationConfig`, `TenderlyRestConfig`, `ChainSimulationConfig`, `SimulationLogger`.
+- `simulate(config, params)` — run a bundle through the simulation pipeline.
+- Config types: `SimulationConfig`, `TenderlyRpcConfig`, `ChainSimulationConfig`, `SimulationLogger`.
 - Data types: `SimulationTransaction`, `SimulationAuthorization`, `Transfer`, `SimulateParams`, `SimulationResult`.
-- Errors: `SimulationPackageError` (abstract base — `instanceof` it to catch any package error), `SimulationRevertedError`, `BlacklistViolationError`, `AddressScreeningError`, `ExternalServiceError`, `SimulationValidationError`, `UnsupportedChainError`.
+- Errors: `SimulationPackageError` (abstract base — `instanceof` it to catch any package error), `SimulationRevertedError`, `BlacklistViolationError`, `ExternalServiceError`, `SimulationValidationError`, `UnsupportedChainError`.
 
 ### Deeper docs
 
 See [`CLAUDE.md`](./CLAUDE.md) in this directory for the execution flow diagram,
-backend tradeoffs, authorizations model, screening design, error-handling table,
+backend tradeoffs, authorizations model, error-handling table,
 and recipes for adding a chain or a new backend.
 
 ## Development

package/lib/cjs/errors.d.ts

@@ -25,12 +25,6 @@ export declare class BlacklistViolationError extends SimulationPackageError {
     readonly code = "BLACKLIST_ERROR";
     constructor(message: string, assetChanges?: RetainedAsset[] | undefined);
 }
-/** Sanctioned or compromised address detected. Never bypassable. */
-export declare class AddressScreeningError extends SimulationPackageError {
-    readonly addresses: string[];
-    readonly code = "SCREENING_ERROR";
-    constructor(message: string, addresses: string[]);
-}
 /** Tenderly or RPC service is down. Bypassable — user can proceed. */
 export declare class ExternalServiceError extends SimulationPackageError {
     readonly code = "EXTERNAL_SERVICE_ERROR";

package/lib/cjs/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnsupportedChainError = exports.SimulationValidationError = exports.ExternalServiceError = exports.AddressScreeningError = exports.BlacklistViolationError = exports.SimulationRevertedError = exports.SimulationPackageError = void 0;
+exports.UnsupportedChainError = exports.SimulationValidationError = exports.ExternalServiceError = exports.BlacklistViolationError = exports.SimulationRevertedError = exports.SimulationPackageError = void 0;
 /**
  * Base class for every error this package throws. Transport-agnostic — no HTTP status codes.
  * Consumers pattern-match with `instanceof` on the concrete subclass.
@@ -34,16 +34,6 @@ class BlacklistViolationError extends SimulationPackageError {
     }
 }
 exports.BlacklistViolationError = BlacklistViolationError;
-/** Sanctioned or compromised address detected. Never bypassable. */
-class AddressScreeningError extends SimulationPackageError {
-    addresses;
-    code = "SCREENING_ERROR";
-    constructor(message, addresses) {
-        super(message);
-        this.addresses = addresses;
-    }
-}
-exports.AddressScreeningError = AddressScreeningError;
 /** Tenderly or RPC service is down. Bypassable — user can proceed. */
 class ExternalServiceError extends SimulationPackageError {
     code = "EXTERNAL_SERVICE_ERROR";

package/lib/cjs/index.d.ts

@@ -1,4 +1,3 @@
-export { AddressScreeningError, BlacklistViolationError, ExternalServiceError, SimulationPackageError, SimulationRevertedError, SimulationValidationError, UnsupportedChainError, } from "./errors.js";
-export { screenAddresses } from "./screen-addresses/index.js";
+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, TenderlyRestConfig, Transfer, } from "./types.js";
+export type { ChainSimulationConfig, RawLog, SimulateParams, SimulationAuthorization, SimulationCall, SimulationConfig, SimulationLogger, SimulationResult, SimulationTransaction, TenderlyRpcConfig, Transfer, } from "./types.js";

package/lib/cjs/index.js

@@ -1,17 +1,14 @@
 "use strict";
 // Public fns (via feature-folder barrels)
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.simulate = exports.screenAddresses = exports.UnsupportedChainError = exports.SimulationValidationError = exports.SimulationRevertedError = exports.SimulationPackageError = exports.ExternalServiceError = exports.BlacklistViolationError = exports.AddressScreeningError = void 0;
+exports.simulate = exports.UnsupportedChainError = exports.SimulationValidationError = exports.SimulationRevertedError = exports.SimulationPackageError = exports.ExternalServiceError = exports.BlacklistViolationError = void 0;
 // Errors (for instanceof checks by consumers)
 var errors_js_1 = require("./errors.js");
-Object.defineProperty(exports, "AddressScreeningError", { enumerable: true, get: function () { return errors_js_1.AddressScreeningError; } });
 Object.defineProperty(exports, "BlacklistViolationError", { enumerable: true, get: function () { return errors_js_1.BlacklistViolationError; } });
 Object.defineProperty(exports, "ExternalServiceError", { enumerable: true, get: function () { return errors_js_1.ExternalServiceError; } });
 Object.defineProperty(exports, "SimulationPackageError", { enumerable: true, get: function () { return errors_js_1.SimulationPackageError; } });
 Object.defineProperty(exports, "SimulationRevertedError", { enumerable: true, get: function () { return errors_js_1.SimulationRevertedError; } });
 Object.defineProperty(exports, "SimulationValidationError", { enumerable: true, get: function () { return errors_js_1.SimulationValidationError; } });
 Object.defineProperty(exports, "UnsupportedChainError", { enumerable: true, get: function () { return errors_js_1.UnsupportedChainError; } });
-var index_js_1 = require("./screen-addresses/index.js");
-Object.defineProperty(exports, "screenAddresses", { enumerable: true, get: function () { return index_js_1.screenAddresses; } });
-var index_js_2 = require("./simulate/index.js");
-Object.defineProperty(exports, "simulate", { enumerable: true, get: function () { return index_js_2.simulate; } });
+var index_js_1 = require("./simulate/index.js");
+Object.defineProperty(exports, "simulate", { enumerable: true, get: function () { return index_js_1.simulate; } });

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

@@ -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/cjs/simulate/backends/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.simulateTenderlyRest = exports.simulateV1 = void 0;
+exports.simulateTenderlyRpc = exports.simulateV1 = void 0;
 var eth_simulate_v1_js_1 = require("./eth-simulate-v1.js");
 Object.defineProperty(exports, "simulateV1", { enumerable: true, get: function () { return eth_simulate_v1_js_1.simulateV1; } });
-var tenderly_rest_js_1 = require("./tenderly-rest.js");
-Object.defineProperty(exports, "simulateTenderlyRest", { enumerable: true, get: function () { return tenderly_rest_js_1.simulateTenderlyRest; } });
+var tenderly_rpc_js_1 = require("./tenderly-rpc.js");
+Object.defineProperty(exports, "simulateTenderlyRpc", { enumerable: true, get: function () { return tenderly_rpc_js_1.simulateTenderlyRpc; } });

package/lib/cjs/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/cjs/simulate/backends/tenderly-rpc.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simulateTenderlyRpc = simulateTenderlyRpc;
+const viem_1 = require("viem");
+const zod_1 = require("zod");
+const errors_js_1 = require("../../errors.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
+    .object({
+    output: hexSchema.optional(),
+    error: zod_1.z.string().optional(),
+    errorReason: zod_1.z.string().optional(),
+})
+    .passthrough();
+const logSchema = zod_1.z
+    .object({
+    raw: zod_1.z
+        .object({
+        address: addressSchema,
+        topics: zod_1.z.array(hexSchema).optional(),
+        data: hexSchema.optional(),
+    })
+        .passthrough()
+        .optional(),
+})
+    .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(),
+    error: zod_1.z.string().optional(),
+    errorMessage: zod_1.z.string().optional(),
+})
+    .passthrough();
+const rpcErrorSchema = zod_1.z
+    .object({
+    code: zod_1.z.number().optional(),
+    message: zod_1.z.string(),
+    data: zod_1.z.unknown().optional(),
+})
+    .passthrough();
+function rpcEnvelope(result) {
+    return zod_1.z
+        .object({ result: result.optional(), error: rpcErrorSchema.optional() })
+        .passthrough();
+}
+const singleEnvelope = rpcEnvelope(simResultSchema);
+const bundleEnvelope = rpcEnvelope(zod_1.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.
+ */
+async function simulateTenderlyRpc(params) {
+    const { config, transactions, blockNumber, signal } = params;
+    const firstTx = transactions[0];
+    if (!firstTx) {
+        throw new errors_js_1.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)] };
+        }
+        const json = await rpcRequest({
+            rpcUrl: config.rpcUrl,
+            method: "tenderly_simulateBundle",
+            params: [transactions.map(buildCall), block, stateOverrides],
+            signal,
+        });
+        const result = unwrapResult(bundleEnvelope.parse(json));
+        return { calls: result.map(toRawCall) };
+    }
+    catch (error) {
+        if (error instanceof errors_js_1.SimulationRevertedError)
+            throw error;
+        if (error instanceof errors_js_1.ExternalServiceError)
+            throw error;
+        throw new errors_js_1.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 errors_js_1.ExternalServiceError(`Tenderly RPC returned ${response.status}: ${response.statusText}`);
+    }
+    return await response.json();
+}
+function unwrapResult(envelope) {
+    if (envelope.error) {
+        throw new errors_js_1.ExternalServiceError(`Tenderly RPC error: ${envelope.error.message}`);
+    }
+    if (envelope.result === undefined) {
+        throw new errors_js_1.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: (0, viem_1.numberToHex)(tx.value ?? 0n),
+    };
+}
+function buildStateOverrides(sender) {
+    return { [sender]: { balance: (0, viem_1.numberToHex)(viem_1.maxUint256) } };
+}
+function encodeBlock(blockNumber) {
+    if (blockNumber === undefined)
+        return "latest";
+    return typeof blockNumber === "bigint"
+        ? (0, viem_1.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 errors_js_1.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),
+        assetChanges: data.assetChanges,
+    };
+}

package/lib/cjs/simulate/parsing/transfers.js

@@ -145,7 +145,9 @@ 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/cjs/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/cjs/simulate/pipeline/execute-simulation.js

@@ -23,33 +23,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).
  */
 async function executeSimulation(params) {
-    const { config, chainId, transactions, blockNumber, shareable } = params;
+    const { config, chainId, transactions, blockNumber } = params;
     const chain = (0, resolve_chain_js_1.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 (0, index_js_1.simulateTenderlyRest)({
-                config: config.tenderlyRest,
-                chainId,
+            return await (0, index_js_1.simulateTenderlyRpc)({
+                config: chain.tenderlyRpc,
                 transactions,
                 blockNumber,
-                shareable,
                 signal: AbortSignal.timeout(tenderlyTimeout),
-                logger: config.logger,
             });
         }
         catch (error) {
@@ -62,8 +56,6 @@ 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 (0, index_js_1.simulateV1)({
                 rpcUrl: chain.simulateV1Url,
@@ -74,6 +66,7 @@ async function executeSimulation(params) {
             });
         }
     }
+    /* v8 ignore next: resolveChain rejects this state before executeSimulation reaches the fallback path. */
     if (!chain.simulateV1Url) {
         throw new errors_js_1.UnsupportedChainError(chainId);
     }

package/lib/cjs/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/cjs/simulate/pipeline/resolve-chain.js

@@ -5,15 +5,18 @@ const errors_js_1 = require("../../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).
  */
 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 errors_js_1.UnsupportedChainError(chainId);
     }
-    return { tenderlySupported, simulateV1Url };
+    return {
+        tenderlyRpc: entry.tenderlyRpc,
+        simulateV1Url: entry.simulateV1Url,
+    };
 }

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

@@ -3,20 +3,19 @@ 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.
+ * - `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]`.
  * - `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 +23,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 +34,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`), and parsed `transfers` (each stamped
+ *   with `txIdx`).
  * @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 +57,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>;