EIP-8079 Native rollups
No call decision · Scaling & data · EIP status Draft · created 2025-11-13
Exposes Ethereum's state transition function (block execution rules) as a new EXECUTE precompile, letting rollups borrow Ethereum's verification infrastructure directly instead of building their own proof system.
Why it is needed
Even rollups that behave equivalently to the EVM currently have to build and maintain a complex separate proof system just to mimic the block validation that Ethereum already performs at L1. This complexity significantly raises the chance of bugs, and prevents projects from removing their security council and reaching Stage 2. It also means that matching Ethereum's functionality requires each rollup to have its own governance, and that governance cannot be forced to follow Ethereum's decisions, so it can diverge arbitrarily. As a result, the best a rollup can do is offer a long exit window, but purposes that rely on timelocked governance, staking, or vesting contracts cannot be fully protected by any finite exit window. This EIP lets rollups reuse Ethereum's state transition verification infrastructure, greatly simplifying rollup infrastructure and upgrade procedures and freeing up resources that can be redirected to user facing features and products.
What changes
Today
- Each rollup builds and maintains its own complex proof system
- Relies on a security council and a long exit window because of bug risk
- Must upgrade itself through separate governance in order to match Ethereum's functionality
After EIP-8079
- Borrows Ethereum's block validation rules directly through a single EXECUTE precompile
- The burden of maintaining a proof system is reduced, freeing resources for user facing features
- Reusing Ethereum's verification infrastructure simplifies the upgrade procedure
Who is affected
- Rollup projects: The burden of maintaining a separate proof system and governance is reduced, and most existing configuration (sequencing method, coinbase, gas policy) can still be kept in smart contracts.
- Rollup users: The bug risk that comes with a complex custom proof system is reduced.
- Client teams: The EXECUTE precompile, the header's burned_fees field, and a proof transaction type all need to be newly implemented.
- Existing rollups: The difficulty of migration varies with the degree of EVM equivalence. Custom opcodes, custom precompiles, and custom transaction types are not supported within the exposed state transition function.
In depth
The EXECUTE precompile
Adds a new precompile at EXECUTE_PRECOMPILE_ADDRESS. It reads chain, block, and anchor from the input and validates state_transition(chain, block). It decodes the block's transactions and fails with ExecuteError if a BlobTransaction is present, meaning blob transactions are not supported within the exposed state transition function. Before the state transition, it performs anchoring by executing a system transaction via process_unchecked_system_transaction targeting ANCHOR_ADDRESS with anchor as the data. The values of PROOF_TX_TYPE, EXECUTE_PRECOMPILE_ADDRESS, and ANCHOR_ADDRESS, along with the input and output encoding, are all TBD in the source.
Header extension: burned_fees
Adds a 64 bit unsigned integer field to the block header encoding. It holds the total amount of the native token burned as base fee in the current block, appended as burned_fees right after withdrawals_root in the header RLP. The cumulative value is computed as burned_fees = effective_gas_fee - gas_refund_amount - transaction_fee + blob_gas_fee. Making this value readable on L1 lets native rollups use it automatically as well. Ethereum burns its base fee, but most rollups collect it and use it as their own revenue. A rollup can choose to ignore this value and also burn its L2 base fee, or it can accumulate the amount at a specific address and adopt a model where the base fee is collected from the L1 to L2 token escrow.
Programmable "consensus layer"
A rollup using the EXECUTE precompile can define its input and behavioral constraints directly in a smart contract. Unlike Ethereum's own consensus layer, it can restrict transaction ordering to a permissioned party to provide centralized sequencing and fast pre-confirmation, open it up to anyone (based sequencing), or limit it to a network of staked sequencers. The coinbase address can be fixed to a DAO controlled treasury independent of the proposer address, and the gas limit or price can be adjusted as needed. This lets a project keep most of the configuration it is already using.
Anchoring and L1 to L2 messaging
Supporting L1 to L2 messages requires anchoring L1 information into L2. Drawing on EIP-4788 and existing implementations, a bytes32 anchor is injected into a predeploy in the rollup state via a system transaction. The anchor can hold whatever a design prefers, such as the L1 state root, a message root, or a rolling hash. Compared to existing approaches based on custom transaction types, this has the tradeoff that on the L2 side of an L1 to L2 message, msg.sender cannot be derived from the L1 sender. As a result, deploying an L1 access control based contract to L2 for use as cross chain permissions requires modification. The source considers this an acceptable tradeoff, since the same situation already exists in the L2 to L1 direction, where Ethereum does not know the L2 sender either.
Gas token handling
Several rollups are implementing new transaction types to mint rollup gas tokens when funds are deposited on L1. This EIP avoids adding that complexity, instead relying, as some existing projects do, on unlocking pre-minted tokens through general purpose L1 to L2 messaging. Since a project is free to decide which L1 interaction triggers the gas token to unlock, custom gas tokens can be supported without changing EVM behavior at all.
Open items and Draft status
Existing rollups can migrate to being native rollups depending on their degree of EVM equivalence, but custom opcodes, custom precompiles, and custom transaction types are not supported within the exposed state transition function. The design of proof-carrying transactions depends heavily on the ZK L1 design and is undecided. A comparison of re-execution versus ZK proofs, test cases, a reference implementation, and security considerations are all TBD. This EIP is in Draft status, created on 2025-11-13, and its content may still change.