Ethereum researchers just published a working proof-of-concept that could fundamentally change how every Layer 2 network on the planet inherits Ethereum’s security — and it doesn’t require a single ZK proof or fraud proof to do it. The Ethrex client team, working in collaboration with the Ethereum Foundation and the L2BEAT team, has completed a proof-of-concept implementation of EIP-8079, a proposal that introduces “native rollups” — a new verification model where Ethereum itself re-executes Layer 2 blocks directly on the base layer via a new mechanism called the EXECUTE precompile.
What Are Native Rollups and How Do They Actually Work?
To understand why this matters, you need to understand the problem it solves. Today, every Layer 2 network on Ethereum — whether it’s Arbitrum, Optimism, Base, or any of the ZK-rollup chains — needs its own mechanism to prove to Ethereum’s base layer that its transactions are valid. Optimistic rollups use fraud proofs: they assume transactions are valid and give challengers a window to dispute them. ZK-rollups use zero-knowledge cryptographic proofs: they generate a mathematical proof that the transactions were executed correctly.
Both approaches work, but both come with significant complexity and maintenance overhead. Fraud proof systems require carefully designed dispute games and long challenge windows (typically seven days). ZK proof systems require sophisticated cryptographic circuits that are expensive to build, audit, and upgrade. Every time Ethereum’s EVM changes — every hard fork, every opcode addition — these proof systems need to be updated to stay in sync with the base layer.
Native rollups, as proposed in EIP-8079, take a completely different approach. Instead of asking Layer 2 networks to prove their state transitions to Ethereum, the proposal exposes Ethereum’s own state transition function through a new EXECUTE precompile. This means Ethereum itself re-executes the Layer 2 blocks, using its own EVM to verify that the L2 state transitions are correct. As the Ethrex team put it on X: “Native rollups reuse Ethereum’s own execution to verify L2 state transitions. No ZK circuits, no fraud proofs, no complex proof systems to maintain.”
The EXECUTE Precompile: Ethereum’s New Superpower
A precompile, in Ethereum terminology, is a built-in smart contract that performs a specific operation at the protocol level, far more efficiently than a regular smart contract could. Existing precompiles handle things like elliptic curve operations and hash functions. The EXECUTE precompile proposed in EIP-8079 would handle something far more ambitious: running Ethereum’s entire state transition function as a verifiable operation that any smart contract — including an L2 bridge contract — can call.
In practical terms, this means an L2 network using native rollups would submit its block data to Ethereum’s base layer, and the EXECUTE precompile would re-run those transactions using Ethereum’s own EVM to confirm the resulting state root is correct. If the state root matches, the L2 block is accepted. If it doesn’t, it’s rejected. The verification is done by Ethereum itself, not by a separate proof system that needs to be maintained in parallel.
“Native rollups reuse Ethereum’s own execution to verify L2 state transitions. No ZK circuits, no fraud proofs, no complex proof systems to maintain. Every L1 block, L2 blocks are settled to L1 via the EXECUTE precompile.”
— Ethrex Client Team (@ethrex_client), X post, March 10, 2026
The Ethrex proof-of-concept, built in collaboration with researchers Kevaundray and Ladislaus from the Ethereum Foundation, demonstrates that this approach is technically feasible. L2 blocks are settled to L1 via the EXECUTE precompile, and the entire verification process happens within Ethereum’s own execution environment — no external proof systems required.
Native Rollups vs. ZK Proofs vs. Fraud Proofs: A Direct Comparison
| Feature | Fraud Proofs (Optimistic) | ZK Proofs | Native Rollups (EIP-8079) |
|---|---|---|---|
| Verification Method | Challenge game | Cryptographic proof | Ethereum re-executes L2 blocks |
| Withdrawal Delay | ~7 days | Minutes to hours | Near-instant (no challenge window) |
| Proof System Maintenance | High (dispute contracts) | Very high (ZK circuits) | None (uses Ethereum’s own EVM) |
| EVM Upgrade Compatibility | Manual updates required | Manual updates required | Automatic (inherits L1 changes) |
| Security Model | Optimistic + honest challenger | Cryptographic soundness | Ethereum consensus directly |
| Development Complexity | High | Very high | Low (no custom proof system) |
One of the most compelling aspects of the native rollup model is its automatic compatibility with future Ethereum upgrades. When Ethereum adds a new opcode or changes its EVM behavior through a hard fork, ZK-rollup circuits and fraud proof systems need to be updated manually to reflect those changes — a process that can take months and introduces risk. With native rollups, the L2 automatically inherits any changes to Ethereum’s execution environment because it’s using Ethereum’s own EVM for verification. As researcher Ladislaus noted on X, “Native rollups and L1-zkEVM proofs are perfectly complementary” — suggesting the two approaches may coexist rather than compete.
What This Means for Arbitrum, Optimism, and Base
The immediate question from the L2 ecosystem is obvious: does this make existing rollup architectures obsolete? The short answer is no — at least not in the near term. EIP-8079 is still at the proof-of-concept stage, and transitioning an existing L2 network to a native rollup architecture would require significant protocol changes. Arbitrum, Optimism, and Base have years of development, security audits, and user trust invested in their current architectures.
But the longer-term implications are significant. For new L2 networks launching after native rollups are available, the barrier to entry drops dramatically. Instead of building and auditing a custom proof system — a process that costs millions of dollars and takes years — a new L2 could inherit Ethereum’s full security guarantees from day one by implementing the EXECUTE precompile interface. This could accelerate the proliferation of application-specific rollups and reduce the technical moat that currently separates established L2 networks from new entrants.
For existing networks, the native rollup model could serve as a fallback or upgrade path. The current Layer 2 landscape is already complex and fragmented — native rollups could eventually provide a standardized security model that simplifies the ecosystem without requiring every L2 to maintain its own proof infrastructure. The debate about what it means to truly “scale Ethereum” takes on new dimensions in light of this development.
The Debate: Elegant Solution or New Set of Trade-offs?
Not everyone in the Ethereum research community is convinced that native rollups are a straightforward improvement. The primary concern is computational cost: if Ethereum’s base layer is re-executing L2 blocks, that computation has to be paid for somehow. The gas costs associated with running the EXECUTE precompile at scale could be substantial, potentially making native rollups economically viable only for L2 networks with relatively low transaction volumes — at least until Ethereum’s own throughput improves significantly.
There is also the question of what happens to the rich ecosystem of ZK proof research that has been built up over the past several years. ZK-rollups have driven enormous advances in cryptography, and the teams building them have developed deep expertise in a technology that has applications far beyond Ethereum scaling. A shift toward native rollups doesn’t eliminate that work, but it does change its strategic importance.
The Ethereum Foundation’s position, as reflected in the 2026 roadmap, appears to be that native rollups and ZK-rollups are complementary rather than competing approaches. The proof-of-concept is a research milestone, not a deployment decision — but it signals that Ethereum’s base layer is being designed with native rollup support in mind, which will shape how the ecosystem evolves over the next several years.
Final Thoughts: A Prototype That Could Reshape the L2 Landscape
The EIP-8079 proof-of-concept is, at this stage, exactly what its name suggests: a proof that the concept works, not a production-ready system. The path from working prototype to deployed Ethereum feature involves years of research, community debate, security analysis, and implementation work. But the significance of this milestone should not be underestimated.
For the first time, Ethereum researchers have demonstrated that the base layer can directly verify L2 state transitions using its own execution environment — no external proof systems required. If that capability makes it into a future Ethereum upgrade, it changes the fundamental economics of building a Layer 2 network. The barrier to entry drops. The maintenance burden shrinks. And Ethereum’s security guarantees become more directly accessible to a wider range of applications.
The question worth watching is not whether native rollups will eventually be deployed — the technical case is compelling enough that some form of this capability seems likely to make it into Ethereum’s roadmap. The question is how quickly the ecosystem adapts, and whether the existing L2 networks that have built their moats on ZK and fraud proof systems will embrace the new model or resist it. That tension will define a significant chapter of Ethereum’s scaling story.
