ERC draft: Independent Simulation Result for (STVA)

Description:

A canonical, content-addressed structure that any independent party (wallet, hardware device, second machine, third-party verifier) can produce and re-verify from the exact same VerificationPayload + state snapshot.

It turns simulation from a trusted frontend service into a reproducible, machine-checkable artifact that can be bound into signatures and Scoped Capability Tokens.

Natural continuity with capability tokens (bind the result hash) and authority lifecycle (simulation is required before high-privilege authority transitions).

author: @MATOBOYCRYPTO65

discussions-to: ERC draft: Independent Simulation Result for (STVA) - ERCs - Fellowship of Ethereum Magicians

status: Draft

type: Standards Track

category: ERC

created: 2026-10-30

Abstract:

Standardizes the format, hashing, and verification of simulation results so that any compliant simulator produces identical canonical output for the same inputs. Enables “recompute on a component the UI does not control.”

Motivation:

A simulation served by a compromised frontend is worthless. Independence + canonicity closes the UI/calldata mismatch class of attacks.

Specification:

Inputs: full preimage of the transaction UserOperation SafeTx (including all fields that enter the hash), block/state root or Merkle proofs of relevant state, optional overrides.

Output (SimulationResult):

success (bool)

gasUsed

returnData logs (canonical encoding)

stateDiff (or hash of stateDiff)

balanceChanges tokenTransfers (structured)

semanticEffects (optional derived summary, preferably recomputed via ERC-7730-style descriptors)

snapshotId (block number + state root)

simulatorId version

Canonical hash: keccak256(abi.encode(SimulationResult)) or a domain-separated EIP-712 hash.

Requirement: hardware offline verifier MUST be able to re-execute (or re-verify proofs) and reject on mismatch.

Compliance: Basic (any simulator), Standard (multi-node consensus on state root), Strict (local revm/EVM execution + Merkle proofs of prestate).

Reference:

struct SimulationResult

bool success;

uint256 gasUsed;

bytes returnData;

bytes32 stateDiffHash;

bytes32 logsHash;

bytes32 snapshotId; blockHash or stateRoot

bytes32 resultHash; self-describing canonical hash

string derivedSummary; optional, claimed or recomputed

Discussion points:

Exact stateDiff encoding (full vs. hash-only for size).

Required prestate proofs vs. trusted RPC with multi-node consensus.

How tightly to bind into the VerificationPayload and capabilities.

Looking forward to feedbacks

Is the idea that the signing device would have an EVM execution engine and you would provide it with a witness (merkle proven pre-execution-state) and then it can fully execute the transaction against that witness?

How does the signing device anchor its trust of the witness to something concrete (like a recent block hash)?

Yes, conceptually the signer can run an EVM against a witness rather than a full local state.

The witness contains the proof of the relevant accounts storage code, and the signer validates those proofs against a trusted state root from a canonical block.

The recent block hash is the commitment point, the witness is the proof that the particular pre-state was indeed the state at that commitment.

The device does not need to trust the witness blindly—it only needs to verify it against the trusted root, then execute and check the transition result.

How does the offline signer get access to a trusted/valid block hash? If the user is trusting a third party for the blockhash, why not just trust that third party for the simulation?

An offline signer still needs a trusted commitment point: a canonical block header, finalized checkpoint, or an authenticated state root.

The witness is then proof that the relevant pre-state is part of that commitment.

The signer verifies the witness, executes locally, and only accepts if the transition is consistent.

So the trust model is not trust the server for the whole simulation, it’s trust a minimal canonical root and verify the specific state data it provides.

Can you help me understand the threat model where a user has access to a trusted commitment point but they don’t have access to a trusted execution?

Trusted commitment without trusted execution is the standard light-client model.

The user trusts the canonical root (block header state root), not the provider. The provider supplies a witness proving the relevant state and execution inputs. The user verifies those proofs against the trusted root, then either executes locally or checks the final transition against the witness proof. If the proofs do not match, the result is rejected. The trust boundary is only the canonical commitment, not the entire execution service.

Ah, so this isn’t intended for offline devices? It is intended for an online device that is following the blockchain with some sort of trustless light client, and can use the witnesses to do local execution with that client without needing to store all of state.

Yes, this is aimed at an online light client or verifier, not a fully offline signer.

The idea is that the client follows the chain, receives a witness proving the relevant pre-state, and locally executes the transaction against that witness without storing the whole state.

The trust boundary is the canonical state root block commitment, not the full execution provider.