If you are in the blockchain space, you have probably heard of “Rollups” – they are Layer 2 (L2) solutions that will help the Ethereum scale by processing transactions in the main chain. But there is always a tradeoff: these rollups often rely on things like multisig wallets (where many people hold keys) or security councils to make sure everything is going well. These are essentially centralized points of failure in an otherwise decentralized system.
Published by Ethereum researcher Drake Justin A
The problem with current rollups
Currently, rollups that want to provide an experience like Ethereum face many challenges:
- Security Councils: Many rollups rely on trusted groups to handle operations.
- Complex proofs of fraud: Optimistic rollups require complex systems to catch bad behavior
- Expensive Snark verification: Zero-knowledge rollups spend a lot of gas prove their proofs
- Ethereum maintenance: When Ethereum has upgraded its policies, rollups need manu -update also
All of these are usually “trust points” that prevent rollups from being safe like the Ethereum L1 itself.
The solution: Perform a precompile
The proposal introduces something called an “execute precompile”. Think of a precompile as a highly efficient, special intelligent contract that is part of the Ethereum protocol itself, which is proven directly by all Ethereum validators. Other precompiles exist for things such as cryptographic operations that are too complicated or slow to do well with a regular intelligent contract. Here's what is EXECUTE Precompile is:
EXECUTE(pre_state_root, post_state_root, trace, gas_used)
It checks if:
- The
trace(List of transactions and state changes) are valid - Starting with
pre_state_rootand applyingtraceBring you topost_state_root - Implementation uses exactly
gas_usedamount of gas
In simpler terms: Ethereum validators themselves prove that the rollup transactions are correct, rather than relying on separate security mechanisms.
How can it work?
There are two main ways to implement it:
-
Re -operational approach
Ethereum validators will re-exercise Rollup transactions to prove that they are correct. It's simple but there are limitations on how much processing can be done.
-
Strategy based on snark
It uses zero-knowledge proofs (such as excessive cryptographic receipts) to verify implementation without redoing all tasks. The cool part is that the proposal does not choose a specific snark system -validators can choose which verification clients they want to use, providing a difference and stability.
In summary:
- Deploy
EXECUTEWith a low initial gas cap-the validators are re-exercise. - Rollups have moved on to their state-transition verification to call
EXECUTE(...). - Validators are optionally running ZK-verifier off-chain clients for larger batches.
- Users enjoy instant finality, simpler bridges, and completely distrustful L2S.
Benefits of native rollups
|
Benefit |
Rollups now |
With the native |
|---|---|---|
|
Complexity of Code |
Thousands of lines of fraud-proof or snark logic |
Single-line solidity precompile call |
|
Security risk |
Multisig councils or custom verifiers |
L1 validator's security directly |
|
EGEFERENCE -EVM |
Management required for every hard fork |
Automatically stays in Pag -Sync |
|
Real-time settlement |
Hard for ZK (requires 100 ms proofs) |
A delay of one-slot — easily hitting |
|
Gas costs |
High Snark Verification Cost |
Metered like any other precompile |
For users
- True Security: Your genitals in L2S become as safe as in Ethereum L1 itself
- No more trusted operators: No need to remember about security councils to be -rogue
- Including composability: L2s can contact L1 contracts in real-time
For developers
- Simplicity: The formation of a rollup becomes noticeable -langing simpler
- Automatic updates: When Ethereum upgrade, your rollup will automatically match
- Lower costs: Verification is getting better
For Ethereum
- More Payment Revenues: Since rollups will use Ethereum for the availability of data
- Increased amount of eth: Larger utility and demand for network
- Forward compatibility: Existing L2s have a clear path to upgrade
What about “Rollup”?
Most L2 now holds the rush to themselves using a dedicated server or a small set of servers, often run by the team that built a rollup. It gives them a lot of control (which can be good for user experience, such as immediate confirmations), but it also introduces centralization risks. The sequencer has significant power in ordering and integrating the transaction.
The idea behind a rollup based on a rollup is to decentralize and secure the L2 sequencing layer by tying it directly to the L1 block of Ethereum's L1. In a rollup based, instead of the rollup with its own independent sequencer (s), the right to order and suggest the next batch of rollup transactions is given to the current L1 block proposer. This means that the rollup inherits L1 censorship resistance and MEV protection.
In my next article, I will compare the based and native rollup for a clearer understanding of both the architecture and design of the rollup. Watch this space 😉.
What does this mean for you
If you are using rollups today, the idea of native rollups represents a future where you do not need to remember about the Rollup security model different from Ethereum's. Your properties will have the same security guarantee regardless of the layer they have.
For L2 projects, it offers a path to enhance their security without rebuilding from the beginning, which potentially eliminate their most significant weaknesses (centralized substances).
For Ethereum, it boosts its position as the security hub of the ecosystem, gaining more value and making the whole system more stable.
The bottom line
Native rollups represent a straightforward but strong idea: let the Ethereum itself prove the implementation of the rollup. It eliminates the need for security councils, complex proof systems, and other centralized components while maintaining all the benefits of performing rollups.
As Eigenlayer's founder Sreeram Kannan put it on:
“This is a slam dunk idea of @Drakefjustin – expand L1 security on any rollup without random multisigs. Ethereum earns a lot of fees, rollups are gaining strong security, and everyone wins.”
It is a “slam dunk idea” that creates a win-win situation for both Ethereum and its L2 ecosystem. This expands the Ethereum security offer to resolve a real point of pain while increasing the income of ETH charge and amount.
