EIP-8357 EVM verification key registry

No call decision · Scaling & data · EIP status Draft · created 2026-07-30

Records the hashes of L1-approved EVM verification keys and their input schema IDs in a fixed-address system contract, so contracts such as native rollups can look up current and past verification keys.

Why it is needed

A native rollup aims to inherit Ethereum L1's execution environment and upgrade process directly, without maintaining a separate verifier or governance. To do that, the rollup contract needs to know which verification key L1 has approved for EVM execution proofs. EIP-8288 verifies proofs using whatever verification key hash the caller supplies, but does not reveal which hash L1 recognizes, which hash is currently valid, or what input schema each program receives. Contracts need this schema information to reconstruct a program's public outputs. If each rollup hardcodes these values, then every time L1 has a feature fork, each rollup must either upgrade through its own governance or stay on an old EVM. This EIP solves this by recording the fork-approved verification key hashes and schema IDs in a fixed-address registry.

What changes

Today

After EIP-8357

Who is affected

In depth

Registry state and storage layout

The registry resides at EVM_VK_REGISTRY_ADDRESS (0x00005e9c1447c1a05a642ec9eb76d9c125468357). verification_key_hash is the 32-byte field for EIP-8288's LEANSTARK_SCHEME, the hash of a STARK verification key. For each registered hash, the schema_id (a nonzero uint16, defined in EIP-8025) of the stateless input that program receives is stored. Slot 0 (CURRENT_VERIFICATION_KEY_HASH_SLOT) holds the current hash, and each hash's schema_id is stored at keccak256(verification_key_hash || uint256(SCHEMA_ID_MAPPING_SLOT)) (standard Solidity mapping layout, with SCHEMA_ID_MAPPING_SLOT = 1). A nonzero value at that slot indicates the entry is registered. Entries can only be appended; deletion or overwriting is forbidden. The all-zero hash is reserved for querying the current entry and cannot be registered.

Read behavior

A non-system-address caller sends exactly 32 bytes of calldata. An all-zero word requests the current entry; a nonzero word requests that hash's entry. A valid request returns 64 bytes in the form verification_key_hash || schema_id, with schema_id encoded as a 32-byte big-endian word padded with zeros. If the calldata is malformed, the call value is nonzero, or the selected hash has no registered entry, it reverts with no return data. Read behavior does not change state.

Fork update: registration and reactivation

The fork update only runs when CALLER is SYSTEM_ADDRESS (0xfffffffffffffffffffffffffffffffffffffffe). A 64-byte calldata (verification_key_hash || schema_id) is a registration. If the hash is nonzero, not yet registered, and schema_id is between 1 and 2**16 - 1 inclusive, the schema_id is stored and the current pointer is switched to that hash. A 32-byte calldata is a reactivation. For an already-registered nonzero hash, only the current pointer is switched and the stored schema_id is left untouched. Violating any condition reverts. Because behavior is split by caller, 32-byte reactivation calls are never confused with 32-byte reads.

Procedure for adding and reactivating hashes

A new verification_key_hash must be declared in a separate Core EIP that lists this EIP in its requires header, and it activates at a hard fork. That EIP must define the exact hash, the L1 feature fork the corresponding verification key represents, and the schema_id of the input the program receives. The hard fork activating this EIP must jointly activate exactly one such Core EIP, and that hash becomes the registry's first verification_key_hash. Reactivating a past hash also requires a separate Core EIP, which in this case only needs to define the hash and the target L1 fork. Since the schema is a property of the program the verification key points to, not a property of the hard fork doing the reactivation, schema_id does not change.

Block processing rules

In the first block where a hard fork selects a new or reactivated hash as the current value (including the fork that activates the registry), the execution client must call the registry on behalf of SYSTEM_ADDRESS before processing transactions, passing EVM_VK_REGISTRY_UPDATE calldata with a value of 0. This call uses the SYSTEM_CALL_GAS_LIMIT from EIP-8037. The gas it consumes is added to neither block_execution_gas_used nor block_state_gas_used, and it is excluded from the block gas limit check. It does not follow EIP-1559 fee burning and is treated as a pre-transaction system contract call under EIP-7928. The block is invalid if the registry address has no code or if the call fails. This call must not be performed in any other block.

Deterministic deployment

The registry must be deployed via the FACTORY_ADDRESS from EIP-7997. Any account can deploy it with an ordinary transaction that concatenates REGISTRY_DEPLOYMENT_SALT and REGISTRY_INITCODE, and under EIP-1014 rules the address is fixed as EVM_VK_REGISTRY_ADDRESS. Because the address is bound to the initcode, changing the runtime code would also change the address. Deployment itself does not activate this EIP or register any hash. Since the first system call runs before transaction processing in the activation block, the deployment transaction must be included in a block earlier than the activation fork's first block. From the activation fork onward, that address must hold REGISTRY_RUNTIME_CODE, have a nonce of 1 under EIP-161, and the corresponding EIP-7910 systemContracts object must include an EVM_VK_REGISTRY_ADDRESS entry in alphabetical key order.

Security considerations

Consumers who follow the current entry automatically accept whichever verification key hash the fork selects. After a transition, proofs made with the previous verification key may fail, and a rollup that cannot produce proofs with the new verification key could halt. Consumers that need their own upgrade grace period can pin exactly one registered hash. On the other hand, a registered hash is never revoked even if proofs for that verification key are later judged unsafe, so consumers who choose a past entry bear that risk themselves.

Current status

This EIP is a Draft-status Standards Track (Core) proposal created on July 30, 2026, and its specification may still change. It requires EIP 161, 1014, 1559, 7910, 7928, 7997, 8025, 8037, and 8288, so it is affected by changes to those proposals as well. The call records provided so far contain no decision to include this EIP in any specific fork.

Original EIP · ← EIPs