@morpho-org/evm-simulation 5.1.0 → 6.0.0

package/lib/cjs/simulate/request/parse-request.d.ts

@@ -1,7 +1,7 @@
 import { type Address, type BlockTag, type Hex } from "viem";
 import type { SimulationAuthorization } from "../../authorizations.js";
 import type { SimulationLimits } from "../../limits.js";
-import { type SimulateParams, type SimulationMode } from "../../params.js";
+import { type SimulateParams, type SimulationMode, type StateBlock } from "../../params.js";
 /** A normalized user transaction: checksummed addresses, `value` defaulted to `0n`.
  * @internal
  */
@@ -21,6 +21,7 @@ export interface ParsedRequest {
     /** Always empty in final mode. */
     readonly authorizations: readonly SimulationAuthorization[];
     readonly blockNumber?: bigint | Exclude<BlockTag, "pending">;
+    readonly block?: StateBlock;
     readonly limits?: SimulationLimits;
 }
 /**

package/lib/cjs/simulate/request/parse-request.js

@@ -52,6 +52,7 @@ const PERMIT2_MESSAGE_KEYS = PERMIT2_TRANSFER_FIELDS.map((field) => field.name);
 const PERMIT2_PERMITTED_KEYS = ["token", "amount"];
 const BLUE_AUTHORIZATION_MESSAGE_KEYS = BLUE_AUTHORIZATION_FIELDS.map((field) => field.name);
 const TRANSACTION_KEYS = ["from", "to", "data", "value"];
+const BLOCK_KEYS = ["number", "hash", "timestamp"];
 const LIMITS_KEYS = ["operations"];
 const AUTHORIZATION_KEYS = {
     erc20Approval: ["type", "token", "owner", "spender", "amount"],
@@ -570,6 +571,7 @@ function parseRequest(input) {
             "chainId",
             "transactions",
             "blockNumber",
+            "block",
             "mode",
             "authorizations",
             "limits",
@@ -652,6 +654,24 @@ function parseRequest(input) {
             }
         }
     }
+    // block
+    const rawBlock = input.block;
+    let block;
+    if (rawBlock !== undefined) {
+        if (!isRecord(rawBlock)) {
+            fieldErrors.push("block: must be an object");
+        }
+        else {
+            check.keys(rawBlock, { allow: BLOCK_KEYS, path: "block" });
+            const number = check.uint256(readField(rawBlock, "number"), "block.number");
+            const hash = check.bytes32(readField(rawBlock, "hash"), "block.hash");
+            const timestamp = check.uint256(readField(rawBlock, "timestamp"), "block.timestamp");
+            if (number !== undefined && hash !== undefined && timestamp !== undefined)
+                block = { number, hash: hash.toLowerCase(), timestamp };
+        }
+        if (rawBlockNumber !== undefined)
+            fieldErrors.push("block: cannot be combined with blockNumber");
+    }
     // authorizations
     const rawAuthorizations = input.authorizations;
     const authorizations = [];
@@ -754,6 +774,7 @@ function parseRequest(input) {
         transactions,
         authorizations: mode === "preview" ? authorizations : [],
         ...(blockNumber !== undefined ? { blockNumber } : {}),
+        ...(block !== undefined ? { block } : {}),
         ...(normalizedLimits !== undefined ? { limits: normalizedLimits } : {}),
     });
 }

package/lib/cjs/simulate/run-simulation.js

@@ -45,21 +45,16 @@ async function runSimulation(params) {
     if (requiresMorpho && addresses?.blue == null)
         throw new errors_js_1.UnsupportedChainError(request.chainId);
     const morpho = addresses?.blue ?? viem_1.zeroAddress;
-    await (0, index_js_1.assertEndpointChain)({
-        client,
-        chainId: request.chainId,
-        mode: request.mode,
-        blockNumber: typeof request.blockNumber === "bigint" ? request.blockNumber : undefined,
-    });
     // Monad nodes reject `validation: false` and charge no gas in the simulated
     // block either way. Its `latest` block is not final: simulating at its number
     // runs on another parent, so default to `finalized`.
     const monad = request.chainId === blue_sdk_1.ChainId.MonadMainnet;
-    const pinnedBlock = await (0, resolve_pinned_block_js_1.resolvePinnedBlock)({
-        client,
-        blockNumber: request.blockNumber ?? (monad ? "finalized" : undefined),
-        signal,
-    });
+    const pinnedBlock = request.block ??
+        (await (0, resolve_pinned_block_js_1.resolvePinnedBlock)({
+            client,
+            blockNumber: request.blockNumber ?? (monad ? "finalized" : undefined),
+            signal,
+        }));
     // With no calldata decoding, the caller's declared `limits.operations`
     // entries are the operations: subjects for state reads and per-operation
     // checks come straight from the limit list.
@@ -85,7 +80,7 @@ async function runSimulation(params) {
         preparations,
         reads: observations.reads,
     });
-    // Execute against the block resolved once above; the boundary rechecks its hash.
+    // Execute against the block resolved once above.
     const execution = await (0, index_js_1.executePlan)({
         client,
         plan,

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

@@ -4,11 +4,11 @@ import type { SimulationConfig } from "../types.js";
 /**
  * Simulate a bundle of EVM transactions.
  *
- * Parses and normalizes the request → resolves the chain identity → resolves
- * a single pinned block → resolves quoted-asset metadata → plans state reads
- * and the execution → executes once through `eth_simulateV1` under the full
- * timeout budget (simulation with in-block state reads → response parsing →
- * reorg check) → derives ERC20/WETH9 transfers and net asset changes from the
+ * Parses and normalizes the request → resolves a single pinned block (skipped
+ * when `params.block` is supplied) → resolves quoted-asset metadata → plans
+ * state reads and the execution → executes once through `eth_simulateV1` under
+ * the full timeout budget (simulation with in-block state reads → response
+ * parsing) → derives ERC20/WETH9 transfers and net asset changes from the
  * user calls only → decodes quoted balances/positions → runs slippage checks
  * → asserts no funds are retained by standalone `bundles` periphery contracts
  * → returns the result. The caller reads whichever fields they need:
@@ -41,7 +41,9 @@ import type { SimulationConfig } from "../types.js";
  *   `blockOverrides.gasLimit` and `parentHashCheck`, optional logger, and the
  *   overall timeout budget.
  * @param params - Per-call simulation input.
- * @param params.chainId - Chain id the bundle targets; must match the endpoint.
+ * @param params.chainId - Chain id the bundle targets. Sent on every call inside
+ *   `eth_simulateV1`, so nodes that check it reject a wrong-chain endpoint;
+ *   there is no separate `eth_chainId` lookup.
  * @param params.transactions - The bundle's transactions, in execution order.
  *   All must share the same `from`.
  * @param params.mode - `"final"` (default) or `"preview"`.
@@ -51,9 +53,14 @@ import type { SimulationConfig } from "../types.js";
  *   than `"pending"`.
  *   Defaults to `latest` (`finalized` on Monad, whose `latest` block is not
  *   final), resolved exactly once.
+ * @param params.block - Optional caller-supplied state block (`number`,
+ *   `hash`, `timestamp`). Skips the block lookup, so a simulation without
+ *   asset metadata reads makes a single `eth_simulateV1` request. Cannot be
+ *   combined with `blockNumber`.
  * @throws {SimulationValidationError} for invalid input (mixed senders, bad
  *   addresses, empty transactions, malformed authorizations, final-mode
- *   authorizations, malformed limits, unknown fields, a `"pending"` block tag, a
+ *   authorizations, malformed limits, unknown fields, a `"pending"` block tag,
+ *   a malformed `block` or one combined with `blockNumber`, a
  *   `blockOverrides.gasLimit` that is not a positive bigint, a `parentHashCheck`
  *   that is not a boolean, or share quotes for
  *   `blueSupplyCollateral` / `blueWithdrawCollateral`).
@@ -69,20 +76,21 @@ import type { SimulationConfig } from "../types.js";
  * @throws {InvalidSimulationResponseError} when the node response cannot be
  *   trusted (bad shape, call-count mismatch, block that is neither the pinned
  *   state block nor its immediate successor, a successor with a mismatched
- *   `parentHash` (unless `parentHashCheck` is off; off by default on Stable, chain 988), a block timestamp earlier than the pinned block's, a
- *   malformed per-call result, a quoted balance/position read whose non-empty
- *   return data cannot be decoded, a state-block hash that changed or a pinned
- *   block that vanished mid-flight, or an
- *   endpoint whose `eth_chainId` differs from `params.chainId`; chain identity
- *   is checked before any block lookup).
+ *   `parentHash` (unless `parentHashCheck` is off; off by default on Stable,
+ *   chain 988), a block timestamp earlier than the pinned block's, a
+ *   malformed per-call result, or a quoted balance/position read whose
+ *   non-empty return data cannot be decoded).
+ * @throws {InvalidChainIdError} when the node rejects the request `chainId`
+ *   because the endpoint serves another chain (a subclass of
+ *   `InvalidSimulationResponseError` sharing its `name`/`code`;
+ *   `instanceof InvalidChainIdError` tells them apart). Never bypassable.
  * @throws {BlacklistViolationError} when the simulation leaves value retained
  *   beyond the dust threshold by a `bundles` periphery contract
- *   (VaultExitBundlesV1, VaultBundlesV1, BlueBundlesV1, MidnightBundlesV1).
+ *   (VaultExitBundlesV1, VaultBundlesV1, BlueBundlesV1, MidnightBundlesV2).
  *   Never bypassable.
  * @throws {ExternalServiceError} when the RPC is unavailable within the
- *   timeout budget or returns a malformed JSON-RPC envelope. Chain-id
- *   mismatches and a state block without number/hash are reported as
- *   `InvalidSimulationResponseError`.
+ *   timeout budget or returns a malformed JSON-RPC envelope. A looked-up state
+ *   block without number/hash is reported as `InvalidSimulationResponseError`.
  * @returns A frozen {@link VerifiedSimulationResult} carrying the normalized
  *   `simulationTxs`, per-tx `calls` (aligned 1:1), parsed `transfers` (each
  *   stamped with `txIdx`), per-account net `assetChanges`, and per-operation

package/lib/cjs/simulate/simulate.js

@@ -6,11 +6,11 @@ const run_simulation_js_1 = require("./run-simulation.js");
 /**
  * Simulate a bundle of EVM transactions.
  *
- * Parses and normalizes the request → resolves the chain identity → resolves
- * a single pinned block → resolves quoted-asset metadata → plans state reads
- * and the execution → executes once through `eth_simulateV1` under the full
- * timeout budget (simulation with in-block state reads → response parsing →
- * reorg check) → derives ERC20/WETH9 transfers and net asset changes from the
+ * Parses and normalizes the request → resolves a single pinned block (skipped
+ * when `params.block` is supplied) → resolves quoted-asset metadata → plans
+ * state reads and the execution → executes once through `eth_simulateV1` under
+ * the full timeout budget (simulation with in-block state reads → response
+ * parsing) → derives ERC20/WETH9 transfers and net asset changes from the
  * user calls only → decodes quoted balances/positions → runs slippage checks
  * → asserts no funds are retained by standalone `bundles` periphery contracts
  * → returns the result. The caller reads whichever fields they need:
@@ -43,7 +43,9 @@ const run_simulation_js_1 = require("./run-simulation.js");
  *   `blockOverrides.gasLimit` and `parentHashCheck`, optional logger, and the
  *   overall timeout budget.
  * @param params - Per-call simulation input.
- * @param params.chainId - Chain id the bundle targets; must match the endpoint.
+ * @param params.chainId - Chain id the bundle targets. Sent on every call inside
+ *   `eth_simulateV1`, so nodes that check it reject a wrong-chain endpoint;
+ *   there is no separate `eth_chainId` lookup.
  * @param params.transactions - The bundle's transactions, in execution order.
  *   All must share the same `from`.
  * @param params.mode - `"final"` (default) or `"preview"`.
@@ -53,9 +55,14 @@ const run_simulation_js_1 = require("./run-simulation.js");
  *   than `"pending"`.
  *   Defaults to `latest` (`finalized` on Monad, whose `latest` block is not
  *   final), resolved exactly once.
+ * @param params.block - Optional caller-supplied state block (`number`,
+ *   `hash`, `timestamp`). Skips the block lookup, so a simulation without
+ *   asset metadata reads makes a single `eth_simulateV1` request. Cannot be
+ *   combined with `blockNumber`.
  * @throws {SimulationValidationError} for invalid input (mixed senders, bad
  *   addresses, empty transactions, malformed authorizations, final-mode
- *   authorizations, malformed limits, unknown fields, a `"pending"` block tag, a
+ *   authorizations, malformed limits, unknown fields, a `"pending"` block tag,
+ *   a malformed `block` or one combined with `blockNumber`, a
  *   `blockOverrides.gasLimit` that is not a positive bigint, a `parentHashCheck`
  *   that is not a boolean, or share quotes for
  *   `blueSupplyCollateral` / `blueWithdrawCollateral`).
@@ -71,20 +78,21 @@ const run_simulation_js_1 = require("./run-simulation.js");
  * @throws {InvalidSimulationResponseError} when the node response cannot be
  *   trusted (bad shape, call-count mismatch, block that is neither the pinned
  *   state block nor its immediate successor, a successor with a mismatched
- *   `parentHash` (unless `parentHashCheck` is off; off by default on Stable, chain 988), a block timestamp earlier than the pinned block's, a
- *   malformed per-call result, a quoted balance/position read whose non-empty
- *   return data cannot be decoded, a state-block hash that changed or a pinned
- *   block that vanished mid-flight, or an
- *   endpoint whose `eth_chainId` differs from `params.chainId`; chain identity
- *   is checked before any block lookup).
+ *   `parentHash` (unless `parentHashCheck` is off; off by default on Stable,
+ *   chain 988), a block timestamp earlier than the pinned block's, a
+ *   malformed per-call result, or a quoted balance/position read whose
+ *   non-empty return data cannot be decoded).
+ * @throws {InvalidChainIdError} when the node rejects the request `chainId`
+ *   because the endpoint serves another chain (a subclass of
+ *   `InvalidSimulationResponseError` sharing its `name`/`code`;
+ *   `instanceof InvalidChainIdError` tells them apart). Never bypassable.
  * @throws {BlacklistViolationError} when the simulation leaves value retained
  *   beyond the dust threshold by a `bundles` periphery contract
- *   (VaultExitBundlesV1, VaultBundlesV1, BlueBundlesV1, MidnightBundlesV1).
+ *   (VaultExitBundlesV1, VaultBundlesV1, BlueBundlesV1, MidnightBundlesV2).
  *   Never bypassable.
  * @throws {ExternalServiceError} when the RPC is unavailable within the
- *   timeout budget or returns a malformed JSON-RPC envelope. Chain-id
- *   mismatches and a state block without number/hash are reported as
- *   `InvalidSimulationResponseError`.
+ *   timeout budget or returns a malformed JSON-RPC envelope. A looked-up state
+ *   block without number/hash is reported as `InvalidSimulationResponseError`.
  * @returns A frozen {@link VerifiedSimulationResult} carrying the normalized
  *   `simulationTxs`, per-tx `calls` (aligned 1:1), parsed `transfers` (each
  *   stamped with `txIdx`), per-account net `assetChanges`, and per-operation

package/lib/cjs/types.d.ts

@@ -13,7 +13,7 @@ export interface ChainSimulationConfig {
     };
     /**
      * Whether a simulated successor block's `parentHash` must equal the pinned
-     * state block hash. Block number, timestamp and reorg checks always run.
+     * state block hash. Block number and timestamp checks always run.
      * Omitted: on everywhere except Stable (988), whose nodes report a
      * `parentHash` that never matches the pinned block.
      */

package/lib/esm/errors.d.ts

@@ -136,7 +136,7 @@ export interface RetainedAsset {
 }
 /**
  * Thrown when net value above the dust threshold is retained by a restricted bundles contract
- * (VaultExitBundlesV1, VaultBundlesV1, BlueBundlesV1 or MidnightBundlesV1) after simulation;
+ * (VaultExitBundlesV1, VaultBundlesV1, BlueBundlesV1 or MidnightBundlesV2) after simulation;
  * pass-through flows and net outflows are allowed. Never bypassable.
  */
 export declare class BlacklistViolationError extends SimulationPackageError {
@@ -175,11 +175,26 @@ export declare class UnsupportedOperationError extends SimulationPackageError {
     readonly name = "UnsupportedOperationError";
     readonly code = "UNSUPPORTED_OPERATION";
 }
-/** The simulation backend returned a response that cannot be parsed. */
+/**
+ * The simulation backend returned a response that cannot be parsed.
+ * {@link InvalidChainIdError} subclasses this class and shares its `name`
+ * and `code`; check `instanceof InvalidChainIdError` first to tell the two
+ * apart.
+ */
 export declare class InvalidSimulationResponseError extends SimulationPackageError {
     readonly name = "InvalidSimulationResponseError";
     readonly code = "INVALID_SIMULATION_RESPONSE";
 }
+/**
+ * The node rejected the request `chainId`: the endpoint is on a different
+ * chain than configured. This is misconfiguration, not an outage, so unlike
+ * {@link ExternalServiceError} callers must not bypass it.
+ * Extends {@link InvalidSimulationResponseError} and shares its `name` and
+ * `code`, so v5 callers that match on either still catch it;
+ * `instanceof InvalidChainIdError` is how to tell the two apart.
+ */
+export declare class InvalidChainIdError extends InvalidSimulationResponseError {
+}
 /** State needed to verify an operation could not be fetched or derived. */
 export declare class MissingVerificationEvidenceError extends SimulationPackageError {
     readonly name = "MissingVerificationEvidenceError";

package/lib/esm/errors.js

@@ -60,7 +60,7 @@ export class SimulationRevertedError extends SimulationPackageError {
 }
 /**
  * Thrown when net value above the dust threshold is retained by a restricted bundles contract
- * (VaultExitBundlesV1, VaultBundlesV1, BlueBundlesV1 or MidnightBundlesV1) after simulation;
+ * (VaultExitBundlesV1, VaultBundlesV1, BlueBundlesV1 or MidnightBundlesV2) after simulation;
  * pass-through flows and net outflows are allowed. Never bypassable.
  */
 export class BlacklistViolationError extends SimulationPackageError {
@@ -109,11 +109,26 @@ export class UnsupportedOperationError extends SimulationPackageError {
     name = "UnsupportedOperationError";
     code = "UNSUPPORTED_OPERATION";
 }
-/** The simulation backend returned a response that cannot be parsed. */
+/**
+ * The simulation backend returned a response that cannot be parsed.
+ * {@link InvalidChainIdError} subclasses this class and shares its `name`
+ * and `code`; check `instanceof InvalidChainIdError` first to tell the two
+ * apart.
+ */
 export class InvalidSimulationResponseError extends SimulationPackageError {
     name = "InvalidSimulationResponseError";
     code = "INVALID_SIMULATION_RESPONSE";
 }
+/**
+ * The node rejected the request `chainId`: the endpoint is on a different
+ * chain than configured. This is misconfiguration, not an outage, so unlike
+ * {@link ExternalServiceError} callers must not bypass it.
+ * Extends {@link InvalidSimulationResponseError} and shares its `name` and
+ * `code`, so v5 callers that match on either still catch it;
+ * `instanceof InvalidChainIdError` is how to tell the two apart.
+ */
+export class InvalidChainIdError extends InvalidSimulationResponseError {
+}
 /** State needed to verify an operation could not be fetched or derived. */
 export class MissingVerificationEvidenceError extends SimulationPackageError {
     name = "MissingVerificationEvidenceError";

package/lib/esm/index.d.ts

@@ -1,9 +1,9 @@
 export type { BlueAuthorization, BlueAuthorizationSignature, BlueAuthorizationTypedData, Eip712Domain, Eip712Field, Erc20ApprovalAuthorization, Erc2612PermitAuthorization, Erc2612PermitTypedData, Permit2TransferAuthorization, Permit2TransferTypedData, SimulationAuthorization, } from "./authorizations.js";
 export type { RetainedAsset, SimulationErrorCode, SimulationErrorContext, SimulationExecutionContext, SimulationExecutionReason, SimulationPreparationContext, SimulationStage, SimulationTransportContext, SimulationValidationContext, SimulationVerificationContext, } from "./errors.js";
-export { AuthorizationRequestMismatchError, BlacklistViolationError, ConsumerLimitViolationError, ExternalServiceError, InvalidSimulationResponseError, isSimulationPackageError, MissingVerificationEvidenceError, SIMULATION_ERROR_CODES, SimulationPackageError, SimulationRevertedError, SimulationValidationError, UnexpectedSimulationError, UnsupportedChainError, UnsupportedOperationError, } from "./errors.js";
+export { AuthorizationRequestMismatchError, BlacklistViolationError, ConsumerLimitViolationError, ExternalServiceError, InvalidChainIdError, InvalidSimulationResponseError, isSimulationPackageError, MissingVerificationEvidenceError, SIMULATION_ERROR_CODES, SimulationPackageError, SimulationRevertedError, SimulationValidationError, UnexpectedSimulationError, UnsupportedChainError, UnsupportedOperationError, } from "./errors.js";
 export type { BlueMarketOperationSubject, BlueMarketOperationType, BlueRefinanceSubject, OperationLimit, OperationType, SimulationLimits, SimulationOperationSubject, SlippageLimits, SlippageQuote, VaultOperationSubject, VaultOperationType, VaultV1MigrateToV2Subject, } from "./limits.js";
 export { BLUE_MARKET_OPERATION_TYPES, OPERATION_TYPES, VAULT_OPERATION_TYPES, } from "./limits.js";
-export type { SimulateParams, SimulationMode, } from "./params.js";
+export type { SimulateParams, SimulationMode, StateBlock, } from "./params.js";
 export { SIMULATION_MODES } from "./params.js";
 export { toSimulationAuthorizations } from "./requirements/index.js";
 export type { AuthorizationPreparation, SimulatedOperation, SimulationVerification, VerifiedSimulationResult, } from "./result.js";

package/lib/esm/index.js

@@ -1,6 +1,6 @@
 // Public fns (via feature-folder barrels)
 // Errors (for instanceof checks by consumers)
-export { AuthorizationRequestMismatchError, BlacklistViolationError, ConsumerLimitViolationError, ExternalServiceError, InvalidSimulationResponseError, isSimulationPackageError, MissingVerificationEvidenceError, SIMULATION_ERROR_CODES, SimulationPackageError, SimulationRevertedError, SimulationValidationError, UnexpectedSimulationError, UnsupportedChainError, UnsupportedOperationError, } from "./errors.js";
+export { AuthorizationRequestMismatchError, BlacklistViolationError, ConsumerLimitViolationError, ExternalServiceError, InvalidChainIdError, InvalidSimulationResponseError, isSimulationPackageError, MissingVerificationEvidenceError, SIMULATION_ERROR_CODES, SimulationPackageError, SimulationRevertedError, SimulationValidationError, UnexpectedSimulationError, UnsupportedChainError, UnsupportedOperationError, } from "./errors.js";
 export { BLUE_MARKET_OPERATION_TYPES, OPERATION_TYPES, VAULT_OPERATION_TYPES, } from "./limits.js";
 export { SIMULATION_MODES } from "./params.js";
 export { toSimulationAuthorizations } from "./requirements/index.js";

package/lib/esm/params.d.ts

@@ -1,4 +1,4 @@
-import type { BlockTag } from "viem";
+import type { BlockTag, Hex } from "viem";
 import type { SimulationAuthorization } from "./authorizations.js";
 import type { SimulationLimits } from "./limits.js";
 import type { SimulationTransaction } from "./types.js";
@@ -6,6 +6,15 @@ import type { SimulationTransaction } from "./types.js";
 export declare const SIMULATION_MODES: readonly ["preview", "final"];
 /** Simulation mode: `"preview"` accepts pending authorizations, `"final"` does not. */
 export type SimulationMode = (typeof SIMULATION_MODES)[number];
+/** A mined block the simulation runs on top of. */
+export interface StateBlock {
+    /** Block number the simulation runs on top of. */
+    readonly number: bigint;
+    /** Hash of that block; compared to the next block's `parentHash`. */
+    readonly hash: Hex;
+    /** Block timestamp in Unix seconds; the simulated block must not be earlier. */
+    readonly timestamp: bigint;
+}
 /**
  * Input to `simulate()`. `authorizations` is accepted only in "preview";
  * `mode` defaults to "final".
@@ -21,6 +30,16 @@ export interface SimulateParams {
      * "latest" block is not final). Only canonical (mined) blocks can be
      * pinned; `pending` has no stable hash and is rejected at runtime. */
     readonly blockNumber?: bigint | Exclude<BlockTag, "pending">;
+    /** State block supplied by the caller, so `simulate()` skips the block
+     * lookup; with no asset metadata reads it then sends only `eth_simulateV1`.
+     * Cannot be combined with `blockNumber`.
+     * Not checked against the endpoint: `hash` is compared only when the node
+     * reports the next block (its `parentHash`) and `parentHashCheck` is on (off
+     * by default on Stable, 988), and `timestamp` only bounds the simulated
+     * block's timestamp. On Monad (143), supply a finalized block: `latest` is
+     * not final there, so the block at that number can change and fail the
+     * `parentHash` check. */
+    readonly block?: StateBlock;
     /** Caller-selected quotes and percentage tolerances. Omitted limits are unchecked. */
     readonly limits?: SimulationLimits;
 }

package/lib/esm/requirements/requirements.js

@@ -130,6 +130,7 @@ export function toSimulationAuthorizations(params) {
         }
         if (isRequirementSignature(requirement)) {
             const { action } = requirement;
+            const actionType = action.type;
             switch (action.type) {
                 case "permit":
                     return toErc2612Permit(action, ctx);
@@ -138,7 +139,7 @@ export function toSimulationAuthorizations(params) {
                 case "authorization":
                     return toBlueAuthorizationSignature(action, ctx);
                 default:
-                    return unsupported(ctx)(`Signature requirement action type "${action.type}" is not supported. Only permit, permit2SignatureTransfer, and authorization signatures are supported`);
+                    return unsupported(ctx)(`Signature requirement action type "${actionType}" is not supported. Only permit, permit2SignatureTransfer, and authorization signatures are supported`);
             }
         }
         return unsupported(ctx)(`Requirement action type "${requirement.action.type}" is not supported. Only erc20Approval, blueAuthorization, permit, permit2SignatureTransfer, and authorization requirements are supported`);

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

@@ -1,32 +1,20 @@
-import { type Client, type PublicClient } from "viem";
-import type { SimulationMode } from "../../params.js";
+import { type Client } from "viem";
+import type { StateBlock } from "../../params.js";
 import type { ExecutionPlan } from "../plan/plan-execution.js";
 import type { SimulationExecution } from "./parse-response.js";
-import type { PinnedBlock } from "./resolve-pinned-block.js";
 /** The JSON-RPC methods this boundary calls. */
-type RpcLabel = "eth_getBlock" | "eth_chainId" | "eth_simulateV1";
+type RpcLabel = "eth_getBlock" | "eth_simulateV1";
 /** Run one RPC call; anything thrown becomes a typed boundary error. @internal */
 export declare const rpc: <T>(label: RpcLabel, call: () => Promise<T>) => Promise<T>;
-/** Validate the endpoint identity through the same URL-safe RPC boundary. @internal */
-export declare function assertEndpointChain(params: {
-    readonly client: Pick<PublicClient, "getChainId">;
-    readonly chainId: number;
-    readonly mode: SimulationMode;
-    readonly blockNumber?: bigint;
-}): Promise<void>;
 /**
  * Execute an {@link ExecutionPlan} through a single `eth_simulateV1` call and
- * collect the pinned execution.
+ * collect the pinned execution. This is the boundary's only RPC request.
  *
- * The caller checks the endpoint chain identity and resolves the pinned state
- * block before this boundary. This function uses that same block for the
- * simulation and reorg check under the shared abort/timeout budget.
- *
- * The boundary performs these steps:
+ * The caller resolves (or supplies) the state block before this boundary.
  *
  * 1. **`eth_simulateV1`** — one `blockStateCalls` entry carrying the planned
- *    calls with their per-call `from`, `traceTransfers: true` so the node
- *    synthesizes native-ETH moves as transfer logs, and `validation: false`
+ *    calls with their per-call `from` and `chainId`, `traceTransfers: true`
+ *    so the node synthesizes native-ETH moves as transfer logs, and `validation: false`
  *    (`true` on Monad, whose nodes reject `false` and charge no gas in the
  *    simulated block). Validation-off means gas is not charged, which is how
  *    gas is separated from economic effects. When `blockGasLimit` is set,
@@ -35,32 +23,31 @@ export declare function assertEndpointChain(params: {
  *    **No balance override is
  *    applied** — `value` transfers are funded by the sender's real native
  *    balance.
- * 2. **Response validation** — the response is parsed before the reorg
- *    re-fetch so revert/mismatch evidence already in hand surfaces instead
- *    of being downgraded to a bypassable {@link ExternalServiceError} by a
- *    failing re-fetch. The simulated block must be exactly
+ * 2. **Response validation** — the simulated block must be exactly
  *    `stateBlockNumber` or `stateBlockNumber + 1`: geth-style nodes report
  *    the former's successor while Anvil reports the pinned block itself.
  *    The result records whatever the node returns; consumers must read
  *    {@link ExecutionBlock.blockNumber} and never assume +1.
- * 3. **Reorg check** — the pinned state block is re-fetched last to detect a reorg
- *    that swapped its hash mid-flight (`InvalidSimulationResponseError`).
  *
  * The endpoint must support `eth_simulateV1` with per-call `from`; there is
  * no fallback backend.
  *
- * @param params - Shared simulation client, execution plan, already-pinned
- *   state block, the `validation` flag to send, the optional simulated
- *   block gas limit, and whether to check the successor `parentHash`.
+ * @param params - Shared simulation client, execution plan (its request
+ *   `chainId` is sent on every call), state block, the `validation` flag to
+ *   send, the optional simulated block gas limit, and whether to check the
+ *   successor `parentHash`.
  * @returns Deep-frozen {@link SimulationExecution} — per-transaction call
  *   results and the resolved {@link ExecutionBlock}.
  * @throws {ExternalServiceError} For transport failures, timeouts,
  *   or malformed JSON-RPC envelopes.
  * @throws {InvalidSimulationResponseError} For a response that cannot be
- *   trusted (bad shape, call-count mismatch, block
- *   other than the pinned state block or its successor, a block timestamp
- *   earlier than the pinned block's, a per-call result that fails normalization,
- *   or a state-block hash that changed or is no longer served mid-flight).
+ *   trusted (bad shape, call-count mismatch, block other than the state block
+ *   or its successor, a block timestamp earlier than the state block's, or a
+ *   per-call result that fails normalization).
+ * @throws {InvalidChainIdError} When the node rejects the request `chainId`
+ *   because it serves another chain (a subclass of
+ *   `InvalidSimulationResponseError` sharing its `name`/`code`;
+ *   `instanceof InvalidChainIdError` tells them apart).
  * @throws {MissingVerificationEvidenceError} When a planned state read fails.
  * @throws {SimulationRevertedError} When a preparation or user transaction
  *   reverts or the node reports a bundle-level revert (code 3 / insufficient
@@ -68,9 +55,9 @@ export declare function assertEndpointChain(params: {
  * @internal
  */
 export declare function executePlan(params: {
-    client: Client & Pick<PublicClient, "getBlock">;
+    client: Client;
     plan: ExecutionPlan;
-    stateBlock: PinnedBlock;
+    stateBlock: StateBlock;
     validation: boolean;
     blockGasLimit?: bigint | undefined;
     parentHashCheck: boolean;