The Merge marked a pivotal milestone for Ethereum, completed on September 15, setting the stage for the next major phase in its evolution: The Surge. As outlined by Vitalik Buterin in late 2021, The Surge aims to solve Ethereum’s scalability challenges by drastically reducing transaction fees and increasing throughput. Central to this vision is a rollup-centric roadmap—leveraging Ethereum’s robust security while pushing execution off-chain to Layer 2 (L2) solutions.
At the heart of this transformation lies EIP-4844, also known as Proto-danksharding—a critical upgrade that dramatically reduces data costs for rollups by introducing a new type of transaction designed specifically for temporary data storage. This innovation paves the way for full Danksharding, which could further scale capacity by another 10–100x.
Ethereum’s Evolving Sharding Roadmap
Gone are the days of complex, executable sharded chains with crosslinks. As former Ethereum Foundation researcher Protolambda noted, the current direction emphasizes modular design and data availability sampling (DAS). Instead of bloating Layer 1 (L1) with additional execution environments, Ethereum now focuses on serving as a secure data availability layer for L2 rollups.
This shift was driven by two key insights:
- Avoiding unnecessary complexity at the L1 level ensures faster development cycles and long-term sustainability.
- By decoupling execution from consensus, Ethereum enables specialized scaling solutions—each optimizing independently without requiring protocol-wide coordination.
👉 Discover how next-gen blockchain scaling is redefining efficiency and user experience.
Modular Blockchain Design: Encapsulation Over Complexity
Modularity is central to Ethereum’s future. Inspired by Vitalik Buterin’s framework on encapsulated vs. systemic complexity, Ethereum embraces encapsulation: hiding internal complexity behind simple interfaces. This allows developers to innovate freely within isolated layers—execution, consensus, data availability—without destabilizing the entire system.
In practice, this means:
- L1 (Ethereum Mainnet) handles consensus and data availability.
- L2 Rollups manage transaction execution and state updates.
This separation empowers rollup teams to iterate rapidly—introducing new virtual machines, fee models, or privacy features—without needing approval from core protocol developers.
A key enabler of this architecture is the Engine API, introduced during The Merge. It allows seamless communication between the Proof-of-Stake (PoS) consensus layer and the Ethereum Virtual Machine (EVM) execution layer. This modular interface marked Ethereum’s first major step toward a layered stack.
Connecting L1 and L2: The Role of APIs and Proofs
L1 and L2 systems operate as distinct software stacks connected through well-defined APIs. These interfaces allow L2s to post transaction data to Ethereum while relying on L1 for finality and dispute resolution.
Two primary mechanisms ensure trustless interoperability:
- Fraud Proofs (used in optimistic rollups): Challenge invalid state transitions after the fact.
- Validity Proofs (used in zk-rollups): Cryptographically prove correctness before finalization.
However, even with advanced proof systems, one bottleneck remains: data availability.
Why Data Availability Is the Scaling Bottleneck
Rollup transactions incur three main costs:
- Execution cost – Validated by all network nodes.
- State storage cost – Updating account balances and contract states.
- Data availability cost – Publishing raw transaction data on L1.
While execution and state updates occur off-chain and are relatively cheap, data availability dominates rollup expenses. Currently, rollups publish their transaction batches as calldata within L1 transactions—an inefficient method where every non-zero byte costs 16 gas.
Efforts like calldata compression and proposals such as EIP-4488 (reducing calldata cost to 3 gas per byte) offer incremental improvements. But they don’t address the root issue: using calldata forces rollups to pay for permanent storage of transient data—an unsustainable model as adoption grows.
Enter EIP-4844, which introduces a more elegant solution: temporary, low-cost data blobs.
EIP-4844: Proto-Danksharding Explained
EIP-4844 introduces a new transaction type—blob-carrying transactions—that carry large volumes of temporary data at a fraction of current costs. These blobs can store up to 128 KB of data each and are attached to regular transactions but treated differently by the network.
How Blob Transactions Work
Each blob contains:
- A data blob (the actual payload from rollups).
- A commitment (a cryptographic hash proving the blob’s contents).
The blob itself is stored outside the traditional execution payload, in a structure called a sidecar—a concept borrowed from distributed systems design. Much like a sidecar attached to a motorcycle, it runs alongside the main transaction but operates independently.
Here’s how it flows:
- Rollup sequencers bundle user transactions into batches.
- They create a blob-carrying transaction containing a commitment to the batch.
- The blob sidecar is distributed across consensus-layer clients (e.g., Prysm, Lighthouse).
- Execution clients (e.g., Geth) process the transaction but do not store or read the blob.
- After approximately one month, nodes automatically prune old blobs.
This design ensures that:
- Data remains available long enough for anyone to reconstruct L2 state or challenge fraudulent activity.
- Long-term storage bloat is avoided since blobs are ephemeral.
Key Advantages of Blob Data vs Calldata
| Aspect | Calldata | Blob Data |
|---|---|---|
| Storage Duration | Permanent | ~1 month |
| Cost per Byte | High (16 gas) | Very low (~1–2 gas equivalent) |
| Accessibility | Readable by EVM | Not accessible to smart contracts |
| Node Impact | Increases state size | Minimal long-term footprint |
Because blobs are not processed by the EVM, they require fewer computational resources—making them far cheaper to include in blocks.
👉 See how cutting-edge blockchain upgrades are transforming transaction efficiency.
FAQ: Understanding EIP-4844 and Its Impact
Q: What is Proto-danksharding?
A: Proto-danksharding refers to EIP-4844—a stepping stone toward full Danksharding. It introduces blob-carrying transactions to reduce rollup data costs and test key infrastructure needed for future scaling.
Q: How much cheaper will rollup transactions become?
A: Estimates suggest a 10x to 100x reduction in data publishing costs once EIP-4844 is live, directly translating to lower fees for end users.
Q: Can smart contracts access blob data?
A: No. Blobs are intentionally inaccessible to EVM execution. Contracts can only verify commitments (hashes), ensuring security without bloating computation.
Q: Why delete blobs after one month?
A: Most rollups only need data available for a few days or weeks to enable verification and fraud challenges. Permanent storage would create unnecessary overhead.
Q: How does this support full Danksharding?
A: EIP-4844 lays the foundation—testing blob propagation, commitments, and network handling—before introducing sharded blob distribution across thousands of nodes.
Q: Does this affect Ethereum’s decentralization?
A: On the contrary—it enhances it. By offloading execution and reducing L1 bloat, more participants can run full nodes, strengthening network resilience.
Conclusion: Building the Foundation for Mass Adoption
As rollups mature, data availability becomes the final frontier in Ethereum scaling. EIP-4844 addresses this challenge head-on by introducing an efficient, temporary data storage layer—freeing L1 from permanent calldata bloat while slashing costs for L2s.
By embracing modular architecture, Ethereum shifts from an all-in-one blockchain to a coordinated stack of specialized layers:
- Consensus (PoS)
- Execution (EVM or alternative VMs)
- Data Availability (blobs via EIP-4844)
This separation enables exponential scalability—where innovation happens at the edges, not just at the core.
Proto-danksharding isn’t just an upgrade—it’s a paradigm shift. It sets the stage for Danksharding, where thousands of data shards empower rollups to achieve unprecedented throughput, all while preserving Ethereum’s bedrock principles: security, decentralization, and accessibility.