@morpho-org/evm-simulation 2.0.1 → 3.0.0

package/lib/cjs/simulate/simulate.js

@@ -8,20 +8,19 @@ const index_js_2 = require("./pipeline/index.js");
  * 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
@@ -29,10 +28,6 @@ const index_js_2 = require("./pipeline/index.js");
  * @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.
@@ -44,14 +39,21 @@ const index_js_2 = require("./pipeline/index.js");
  *   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 }],
@@ -60,9 +62,7 @@ const index_js_2 = require("./pipeline/index.js");
  * // result satisfies SimulationResult
  * ```
  */
-// biome-ignore lint/complexity/useMaxParams: TODO refactor to ≤2 params
-async function simulate(config, params, options = {}) {
-    const { shareable = false } = options;
+async function simulate(config, params) {
     (0, index_js_2.validateInput)(params);
     const simulationTxs = (0, index_js_2.buildSimulationTxs)(params);
     const result = await (0, index_js_2.executeSimulation)({
@@ -70,7 +70,6 @@ async function simulate(config, params, options = {}) {
         chainId: params.chainId,
         transactions: simulationTxs,
         blockNumber: params.blockNumber,
-        shareable,
     });
     if (result.calls.length !== simulationTxs.length) {
         throw new errors_js_1.ExternalServiceError(`Backend returned ${result.calls.length} call result(s) for ${simulationTxs.length} transaction(s) — refusing to map transfers with mismatched lengths`);
@@ -85,6 +84,5 @@ async function simulate(config, params, options = {}) {
         simulationTxs,
         calls: result.calls,
         transfers,
-        tenderlyUrl: result.tenderlyUrl,
     };
 }

package/lib/cjs/types.d.ts

@@ -1,36 +1,34 @@
 import type { Address, BlockTag, Hex } from "viem";
 /**
- * Credentials and routing for the Tenderly REST simulation backend.
- * Omit from `SimulationConfig.tenderlyRest` to disable the Tenderly path entirely.
+ * Credentials for the Tenderly Node Web3 Gateway. The `rpcUrl` is the
+ * chain-specific gateway URL with the access key embedded in the path,
+ * e.g. `https://mainnet.gateway.tenderly.co/{ACCESS_KEY}`.
  */
-export interface TenderlyRestConfig {
-    /** e.g. "https://api.tenderly.co" */
-    apiBaseUrl: string;
-    accessToken: string;
-    accountSlug: string;
-    projectSlug: string;
-    /** Chain IDs that Tenderly supports for simulation */
-    supportedChainIds: Set<number>;
+export interface TenderlyRpcConfig {
+    rpcUrl: string;
 }
 /**
- * Per-chain capabilities. Stored as a `Map` value in
- * `SimulationConfig.chains`, keyed by chain ID.
+ * Per-chain backend capabilities. Exactly one configuration shape per chain;
+ * the discriminated union enforces that **at least one** of `tenderlyRpc`
+ * (primary) or `simulateV1Url` (fallback) is supplied.
  */
-export interface ChainSimulationConfig {
-    /** JSON-RPC URL supporting `eth_simulateV1`. undefined = not available for this chain. */
+export type ChainSimulationConfig = {
+    /** Tenderly RPC config — `tenderly_simulateTransaction` / `tenderly_simulateBundle`. */
+    tenderlyRpc: TenderlyRpcConfig;
+    /** JSON-RPC URL supporting `eth_simulateV1`. Optional when Tenderly is set. */
     simulateV1Url?: string;
-}
+} | {
+    tenderlyRpc?: TenderlyRpcConfig;
+    simulateV1Url: string;
+};
 /**
  * Top-level configuration for `simulate`.
  *
- * At least one backend must be reachable for a given chainId — either Tenderly
- * (via `tenderlyRest` with that chainId in `TenderlyRestConfig.supportedChainIds`)
- * or `ChainSimulationConfig.simulateV1Url` in the `chains` map. Otherwise the
- * orchestrator throws `UnsupportedChainError`.
+ * Every chain entry must declare at least one backend (Tenderly RPC primary,
+ * `eth_simulateV1` fallback, or both). Calling `simulate` for a `chainId`
+ * missing from `chains` throws `UnsupportedChainError`.
  */
 export interface SimulationConfig {
-    /** Tenderly REST API config. undefined = Tenderly not available. */
-    tenderlyRest?: TenderlyRestConfig;
     /** Per-chain simulation capabilities. */
     chains: Map<number, ChainSimulationConfig>;
     logger?: SimulationLogger;
@@ -92,8 +90,6 @@ export interface Transfer {
  *   status, returnData/gasUsed, and (Tenderly only) assetChanges per tx.
  * - `transfers[k].txIdx` indexes into `simulationTxs` to attribute each
  *   transfer to its emitting transaction.
- * - `tenderlyUrl` is set only when `shareable: true` AND the Tenderly backend
- *   ran successfully (not the `eth_simulateV1` fallback).
  */
 export interface SimulationResult {
     /** The full resolved transaction list (including prepended authorization txs). */
@@ -106,8 +102,6 @@ export interface SimulationResult {
     readonly calls: readonly SimulationCall[];
     /** Parsed ERC-20 / WETH9 transfers from the simulation. */
     readonly transfers: readonly Transfer[];
-    /** Shareable Tenderly URL. Present only when `shareable: true` and Tenderly ran (not fallback). */
-    readonly tenderlyUrl?: string;
 }
 /** Minimal structured logger the package calls for warnings and info. */
 export interface SimulationLogger {
@@ -132,11 +126,10 @@ export interface SimulateParams {
  */
 export interface RawSimulationResult {
     calls: RawCall[];
-    tenderlyUrl?: string;
 }
 /**
  * Normalized EVM log emitted by a single simulated call. The shape is the
- * common subset both backends (`eth_simulateV1` via viem and Tenderly REST)
+ * common subset both backends (`eth_simulateV1` via viem and Tenderly RPC)
  * produce after schema validation. Returned indirectly via
  * `SimulationCall.logs` and consumed by the SDK's transfer parser.
  */
@@ -156,7 +149,7 @@ export interface RawCall {
     status: boolean;
     returnData: Hex;
     gasUsed: bigint;
-    /** Tenderly-only `asset_changes` payload. Absent on `eth_simulateV1`. */
+    /** Tenderly-only `assetChanges` payload. Absent on `eth_simulateV1`. */
     assetChanges?: unknown;
 }
 /**
@@ -180,7 +173,7 @@ export interface SimulationCall {
     /** Gas used by this call (root frame). */
     readonly gasUsed: bigint;
     /**
-     * Tenderly-only `asset_changes` payload for this tx. Opaque `unknown` —
+     * Tenderly-only `assetChanges` payload for this tx. Opaque `unknown` —
      * do not destructure without validation. Absent on `eth_simulateV1`.
      */
     readonly assetChanges?: unknown;

package/lib/esm/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/esm/errors.js

@@ -28,15 +28,6 @@ export class BlacklistViolationError extends SimulationPackageError {
         this.assetChanges = assetChanges;
     }
 }
-/** Sanctioned or compromised address detected. Never bypassable. */
-export class AddressScreeningError extends SimulationPackageError {
-    addresses;
-    code = "SCREENING_ERROR";
-    constructor(message, addresses) {
-        super(message);
-        this.addresses = addresses;
-    }
-}
 /** Tenderly or RPC service is down. Bypassable — user can proceed. */
 export class ExternalServiceError extends SimulationPackageError {
     code = "EXTERNAL_SERVICE_ERROR";

package/lib/esm/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/esm/index.js

@@ -1,5 +1,4 @@
 // Public fns (via feature-folder barrels)
 // Errors (for instanceof checks by consumers)
-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";

package/lib/esm/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/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,173 @@
+import { isAddress, isHex, maxUint256, numberToHex, } from "viem";
+import { z } from "zod";
+import { ExternalServiceError, SimulationRevertedError, SimulationValidationError, } from "../../errors.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 simResultSchema = z
+    .object({
+    status: z.boolean(),
+    gasUsed: hexSchema,
+    logs: z.array(logSchema).optional(),
+    trace: z.array(traceFrameSchema).optional(),
+    assetChanges: z.unknown().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)] };
+        }
+        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 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),
+        assetChanges: data.assetChanges,
+    };
+}

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,
+    };
 }