Making Ethereum a Rollup of Itself
Rolling
NOTE: This is just me brainstorming and theorizing, rather than a serious proposal.
One of the hot topics in the Ethereum community these days is how to boost the gas limit on the main chain. Many have tried to make the L1 more complex, packing in extra features just to push that gas limit higher. But what if there were another way—a way that doesn’t force us to overcomplicate the core chain? In this post, I would like to explore a thought experiment: what if we could turn Ethereum into a rollup of itself?
Picture this: the current Ethereum execution chain transforms into a native rollup, processing transactions off-chain in super-efficient batches. At the same time, a brand-new Layer 1 (L1) is launched from scratch solely to handle deposits and withdrawals for the beacon chain. And here’s the kicker—the new L1 would run with a very low gas limit (around 10 million or even less) to keep things as simple as possible. This approach would let Ethereum scale its current application layer without overloading the base chain, while the new, minimalistic L1 focuses only on what’s absolutely necessary, including managing the sequencing for calldata-based posts.
Rethinking Ethereum’s Core
Ethereum has always been about decentralization and security, but as usage skyrockets, scalability and high transaction fees are becoming major issues. So, what if we reimagine Ethereum’s setup to work smarter?
- Native Rollup Execution: Imagine transforming the current Ethereum L1 into a native rollup. In this model, transactions are processed off-chain in batches, which means way more transactions per second and lower fees. On-chain, we’d just post periodic proofs or state commitments to keep everything secure.
- A Dedicated Deposit/Withdrawal L1: At the same time, we’d create a new Layer 1 right from genesis. This chain would serve as the gateway for asset deposits and withdrawals, working hand-in-hand with the beacon chain. To keep things simple and secure, it would run with a super low gas limit—around 10 million or even less—since it’s only doing the basics of moving assets around and not intended for Defi or applications.
Let’s break it down
Let’s start with the current Ethereum network reimagined as a rollup:
- Batch Processing & State Commitment: Instead of processing every single transaction on-chain, the network would bundle them up off-chain. Then, it would periodically commit a summary (like a state proof) on-chain. This means fewer on-chain operations and faster throughput.
Optimized Execution Environment: By tweaking the Ethereum Virtual Machine (EVM) for these rollup operations, we can handle quick state transitions more efficiently. Essentially, we get the best of both worlds: off-chain speed and on-chain security.
Security Inheritance: Even though most of the heavy lifting is off-chain, security isn’t sacrificed. The rollup periodically “anchors” its state to the underlying chain, ensuring that everything remains as secure as it is today.
Next, let’s talk about the new L1 chain dedicated to deposits and withdrawals:
Sequencing for Layer 2 Transactions: An important twist here is that the sequencing of current Layer 2s (Arbitrum, Optimism, etc..) transactions—especially those involving calldata-based posts—would be managed on this new L1. This is interesting because this would discourage the use of calldata further in favour of blobs and it is necessary because these rollups still need to inherit the security of the base layer.
Low Gas Limit for Streamlined Operations: To keep things efficient and focused, this chain would have a very low gas limit—around 10 million or even less. It isn’t designed for heavy-duty smart contract processing; it’s all about handling asset transfers and blob data and deposits/withdrawals from/to the beacon chain.
Specialized, Minimalistic Design: With a clear, singular purpose, this chain stays lean. It does one thing really well—managing deposits, withdrawals, and L2 sequencing—without getting bogged down by extra features (like native account abstraction and EOF). This simplicity allows Ethereum to scale its current application layer without overcomplicating the fundamental transfer mechanism.
Why bother?
There are some compelling reasons to consider this approach:
1000x the Gas Limit: By shifting a lot of the heavy transaction processing off-chain into a native rollup, we could potentially boost the effective gas limit by a factor of 10. This means more capacity for transactions without pushing the inherent complexity of the L1.
Unburdening Solo Stakers: The new L1 is extremely lean, which means solo stakers wouldn’t need to run a full, complex node. They’d only need to handle the minimalistic chain, making participation easier and more accessible.
Preserving TVL: Historically, most assets and total value locked (TVL) are on L1, which means users do not need to burden themselves to eventually migrate.
More focused development: Right now, there are 2 things that are pushed to be scaled: Execution gas limit and Blob count. This fragmented development would be easily patched up as the only thing needed would be to focus on blob scaling for Ethereum core.
Reimagining Ethereum as a rollup of itself—where the current L1 becomes a native rollup and a new genesis L1 handles deposits and withdrawals for the beacon chain as well as the sequencing of L2 transactions with a super low gas limit—might just be a wild idea,. This setup could let Ethereum scale its current application layer without overcomplicating the base chain, while the new L1 stays as minimalistic as possible, focused solely on essential tasks like asset movement and transaction ordering. The issue here is that it would add significant code-debt though and this post is just a fun idea on paper, NOT A PROPOSAL.