0xbow Reconstructing the New Order of Tornado Cash Era's Mixer

Author: Zhixiong Pan Source: chainfeeds

In the past two years, the main driving force behind Ethereum's scaling has been various Layer 2 Rollups, such as Arbitrum, Optimism, and Base. While these L2 chains have improved performance, they have led to fragmentation in terms of assets and user experience. Users frequently move across chains, with assets scattered across different networks, resulting in a poor experience, and it is challenging to unify technical and security standards.

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

At the same time, Ethereum researchers have also begun to focus on the standardization and security issues at the protocol layer, which has led to the introduction of EIP-8079 (Native Rollup) that we are going to discuss today.

What is Native Rollup?

In simple terms, the current Rollup processes transactions on its own chain and periodically submits some state data or proofs to the Ethereum main chain (L1) to ensure the authenticity of the execution results. However, each Rollup has its own state machine, proof system, and validation logic, which may lead to complexity and security risks.

The Native Rollup concept proposed by EIP-8079 is centered around adding a new precompiled contract called EXECUTE on the Ethereum main chain, allowing Rollups to directly submit blocks from their own chain to the main chain, which will then re-execute them to verify the validity of the blocks.

This means that Rollups no longer need to implement their own complex state machines or proof systems, but can directly use Ethereum's own kernel execution engine, significantly reducing complexity and security risks. This design is known as “Native Rollup”, which is the true essence of a native Rollup.

Who is driving this proposal?

The authors of EIP-8079 are Luca Donno from L2BEAT and researcher Justin Drake from the Ethereum Foundation. In fact, this idea was proposed and discussed in community forums as early as the beginning of 2025, and it wasn't until recently that it officially formed an EIP draft and entered the discussion stage of technical details.

Technically, what exactly does Native Rollup do?

The core technological change of Native Rollup is the addition of a special precompiled contract - EXECUTE. It allows Rollup to submit a block to L1, which is then directly verified by Ethereum's main chain EVM engine.

The specific process is as follows:

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

When the main chain executes EXECUTE, it will:

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

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

In this way, L2 no longer needs to build a complex verification system on its own, but can directly reuse the mature execution engine of the Ethereum main chain.

Why make such a change?

Currently, each L2 independently implements verification logic, which leads to extremely high maintenance costs and security risks. Whenever the main chain is updated, L2 must be updated synchronously; otherwise, there is a risk of security threats or compatibility issues.

By standardizing the verification logic through Native Rollup, L2 will no longer need to maintain a separate complex set of EVM replicas and verification systems. The entire security model will be simplified to one question: Is the Ethereum main chain secure?

This will also facilitate the gradual removal of temporary security measures such as the security committee and multi-signatures in the future, allowing for a faster realization of a truly decentralized and secure scaling solution.

What restrictions will this impose on L2?

Becoming a Native Rollup requires a key prerequisite: the execution layer must be highly equivalent to the EVM of the Ethereum main chain. This means that L2 cannot arbitrarily add custom opcodes, precompiled contracts, or special transaction types in its own execution environment; otherwise, the EXECUTE of the main chain will not be able to correctly replay the blocks.

But this does not mean that L2 cannot achieve differentiation at all. In fact, L2 can still maintain its own characteristics in terms of economic models, governance methods, transaction ordering mechanisms, etc., but the execution layer itself must strictly adhere to the specifications of the Ethereum main chain.

What does Native Rollup mean for the Ethereum ecosystem?

For L2 project parties, the security and maintenance difficulty will be greatly reduced, and the governance and operational costs of the projects will also decrease accordingly.

For developers, when deploying contracts, they can achieve the same deterministic behavior as the main chain, without needing special adaptations for each L2.

For users, asset security will be significantly enhanced, and the experience will be closer to the “real Ethereum main chain”. In the long term, ecological unity and usability will be greatly improved.

Summary

Ethereum, through the Native Rollup proposal of EIP-8079, provides a standardized execution verification method for L2 at the protocol layer, allowing L2 to genuinely leverage the security and mature infrastructure of the main chain. At the same time, by collaborating with other solutions like EIL, Ethereum is gradually addressing the pain points of the current fragmentation in L2 user experience and asset liquidity.

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