A New Ethereum Upgrade Could Solve Rollups’ Biggest Security Flaw

If you've been in the blockchain space, you've probably heard of "rollups" - they're Layer 2 (L2) solutions that help Ethereum scale by processing transactions off the main chain. But there's always been a tradeoff: these rollups often rely on things like multisig wallets (where multiple people hold keys) or security councils to ensure everything works properly. These are essentially centralized points of failure in an otherwise decentralized system.

Ethereum researcher Drake Justin published a proposal for what he called "native rollups". The aim is to solve this problem by allowing rollups to inherit the full security of Ethereum's Layer 1 (L1) blockchain. Let me break this down in simpler terms.



The Problem With Current RollupsCurrently, rollups that want to provide an Ethereum-like experience face several challenges:Security Councils: Many rollups rely on trusted groups to oversee operations.Complex Fraud Proofs: Optimistic rollups need complicated systems to catch bad behaviorExpensive SNARK Verification: Zero-knowledge rollups spend a lot of gas verifying their proofsKeeping Up With Ethereum: When Ethereum upgrades its rules, rollups need to manually update tooThese are all basically "trust points" that prevent rollups from being as secure as the Ethereum L1 itself.The Solution: EXECUTE PrecompileThe proposal introduces something called an "EXECUTE precompile".

Think of a precompile as a highly efficient, special smart contract that's part of the Ethereum protocol itself, verified directly by all Ethereum validators. Other precompiles exist for things like cryptographic operations that are too complex or slow to do efficiently in a regular smart contract. Here's what the EXECUTE precompile does:EXECUTE(pre_state_root, post_state_root, trace, gas_used)It checks if:The trace (list of transactions and state changes) is validStarting from the pre_state_root and applying the trace gets you to the post_state_rootThe execution uses exactly gas_used amount of gasIn simpler terms: Ethereum's validators themselves verify that rollup transactions are correct, rather than relying on separate security mechanisms.

How Would This Work?There are two main ways this could be implemented:Re-Execution ApproachEthereum validators would simply re-execute the rollup transactions to verify they're correct. This is simple but has limitations on how much processing can be done.SNARK-Based ApproachThis uses zero-knowledge proofs (like super-efficient cryptographic receipts) to verify execution without redoing all the work.

The cool part is that the proposal doesn't pick one specific SNARK system - validators could choose which verification clients they want to use, providing diversity and resilience.In summary:Deploy EXECUTE with a low initial gas cap—validators just re-execute.Rollups switch their state-transition verification to call EXECUTE(.

..).

Validators optionally run zk-verifier clients off-chain for bigger batches.Users enjoy instant finality, simpler bridges, and fully trustless L2s.Benefits of Native Rollups| Benefit | Today’s Rollups | With Native EXECUTE ||----|----|----|| Code complexity | Thousands of lines of fraud-proof or SNARK logic | Single-line Solidity precompile call || Security risk | Multisig councils or custom verifiers | Inherits L1 validator security directly || EVM equivalence | Governance needed for each hard fork | Automatically stays in sync || Real-time settlement | Hard for ZK (needs 100 ms proofs) | One-slot delay—easy to hit || Gas costs | High on-chain SNARK verification cost | Metered like any other precompile |For UsersTrue Security: Your assets on L2s become as secure as on Ethereum L1 itselfNo More Trusted Operators: No need to worry about security councils going rogueSynchronous Composability: L2s could interact with L1 contracts in real-timeFor DevelopersSimplicity: Building a rollup becomes dramatically simplerAutomatic Updates: When Ethereum upgrades, your rollup automatically stays compatibleLower Costs: Verification becomes more efficientFor EthereumMore Fee Revenue: Since rollups would use Ethereum for data availabilityIncreased ETH Value: Greater utility and demand for the networkForward Compatibility: Existing L2s have a clear path to upgradeWhat About "Based Rollups"?Most L2s today handle sequencing themselves using a dedicated server or a small set of servers, often run by the team that built the rollup.

This gives them a lot of control (which can be good for user experience, like instant confirmations), but it also introduces centralization risks. The sequencer has significant power over transaction ordering and inclusion.The idea behind a Based Rollup is to decentralize and secure the L2’s sequencing layer by tying it directly to Ethereum's L1 block production.

In a Based Rollup, instead of the rollup having its own independent sequencer(s), the right to order and propose the next batch of rollup transactions is given to the current L1 block proposer. This means that the rollup inherits the L1's censorship resistance and MEV protection.In my next article, I will be comparing the Based and Native rollups for a clearer understanding of both rollup architecture and design.

Watch this space :wink:.What This Means For YouIf you're using rollups today, the idea of Native rollups represents a future where you don't have to worry about the rollup's security model being different from Ethereum's. Your assets would have the same security guarantees regardless of which layer they're on.

For L2 projects, this offers a path to enhance their security without rebuilding from scratch, potentially eliminating their most significant vulnerability (centralized components).For Ethereum, this strengthens its position as the security hub of the ecosystem, capturing more value and making the whole system more robust.The Bottom LineNative rollups represent a straightforward but powerful idea: let Ethereum itself verify rollup execution.

This eliminates the need for security councils, complex fraud proof systems, and other centralized components while maintaining all the performance benefits of rollups.As Eigenlayer's founder Sreeram Kannan put it: “This is a slam dunk idea by @drakefjustin—extend L1 security to any rollup without random multisigs. Ethereum earns more fees, rollups get strong security, and everyone wins.

”This is a "slam dunk idea" that creates a win-win situation for both Ethereum and its L2 ecosystem. It expands Ethereum's security offering to solve a real pain point while increasing fee revenue and ETH value..