EIP-8079: Reshaping Collaboration and Security Standards Between L1 and L2

Author: Zhixiong Pan Source: chainfeeds

Over the past two years, the main force behind Ethereum scaling has been various Layer 2 Rollups, such as Arbitrum, Optimism, Base, and others. While these L2 chains have improved performance, they have also brought about fragmentation in assets and user experience. Users frequently bridge across chains, assets are scattered across different networks, resulting in a poor experience, and it’s difficult to unify technical and security standards.

To solve the fragmentation at the user experience layer, the Ethereum community recently proposed EIL (Ethereum Interoperability Layer), which enables a unified user experience across multiple L2 networks, making users feel like they are using a single chain rather than multiple independent networks.

At the same time, Ethereum researchers have begun to focus on protocol-level standardization and security issues, which brings us to today’s topic: EIP-8079 (Native Rollup).

What is a Native Rollup?

Simply put, current Rollups process transactions on their own chains and periodically submit some state data or proofs to the Ethereum mainnet (L1) to ensure the correctness of execution results. However, each Rollup has its own state machine, proof system, and verification logic, which can lead to complexity and security risks.

The concept of Native Rollup proposed in EIP-8079 centers around adding a new precompiled contract to the Ethereum mainnet called EXECUTE, allowing Rollups to submit their chain’s blocks directly to the mainnet, which then re-executes the blocks to verify their validity.

This means Rollups no longer need to implement complex state machines or proof systems themselves; instead, they can directly use Ethereum’s own core execution engine, greatly reducing complexity and security risks. This design is called “Native Rollup,” meaning truly native Rollup in the fullest sense.

Who is driving this proposal?

The authors of EIP-8079 are Luca Donno from L2BEAT and Ethereum Foundation researcher Justin Drake. In fact, this idea was discussed in community forums as early as the beginning of 2025, but only recently has it become an official EIP draft and entered the stage of technical discussion.

What does Native Rollup actually change technically?

The core technical change of Native Rollup is the addition of a special precompiled contract—EXECUTE. It allows a Rollup to submit a block to L1, which is then directly validated by the Ethereum mainnet’s own EVM engine.

The specific process is as follows:

The data submitted by the Rollup includes the current L2 state, the block data to be verified, and some anchoring data from L1 to L2.

When the mainnet executes EXECUTE, it will:

• Check the validity of the block (for example, prohibit special types of Blob transactions);
• Inject the anchoring data into a specific system address in the L2 state;
• Call the Ethereum client’s internal state transition function to fully replay the submitted L2 block.

If the replay is successful, the block is valid; otherwise, the block is rejected.

In this way, L2s no longer need to build their own complex verification systems but instead directly reuse the mature execution engine of the Ethereum mainnet.

Why make this change?

Currently, each L2 independently implements its own verification logic, resulting in very high maintenance costs and security risks. Whenever the mainnet is updated, L2s must also update accordingly; otherwise, security vulnerabilities or compatibility issues may arise.

By standardizing verification logic through Native Rollup, L2s will no longer have to maintain an entire set of complex EVM replicas and verification systems. The entire security model is simplified to a single question: is the Ethereum mainnet secure?

This also helps to phase out interim security measures like security councils and multisigs more swiftly, accelerating the realization of truly decentralized and secure scaling solutions.

What limitations does this impose on L2s?

Becoming a Native Rollup requires a critical prerequisite: the execution layer must be highly equivalent to the Ethereum mainnet’s EVM. This means L2s cannot arbitrarily add custom opcodes, precompiled contracts, or special transaction types in their execution environment; otherwise, the mainnet’s EXECUTE will not be able to correctly replay the block.

However, this does not mean L2s cannot differentiate themselves at all. In fact, L2s can still maintain their own characteristics in areas such as economic models, governance mechanisms, and transaction ordering, as long as the execution layer itself strictly follows the Ethereum mainnet’s standards.

What does Native Rollup mean for the Ethereum ecosystem?

For L2 project teams, security and maintenance complexity will be greatly reduced, and governance and operational costs will decrease as well.

For developers, deploying contracts can achieve the same deterministic behavior as on the mainnet, without needing special adaptations for each L2.

For users, asset security will be significantly improved, and the experience will be closer to that of the “real Ethereum mainnet.” In the long run, the ecosystem’s unity and usability will be greatly enhanced.

Summary

Through the Native Rollup proposal in EIP-8079, Ethereum provides a standardized execution verification method at the protocol layer for L2s, allowing them to truly leverage the mainnet’s security and mature infrastructure. At the same time, together with other solutions like EIL, Ethereum is gradually addressing the current pain points of fragmented L2 user experience and asset mobility.

In the future, we may see a more unified and secure Ethereum ecosystem.