The Merge was a consensus change that required no application rewrites. The Surge's rollup-centric scaling demands new data availability layers like Celestia or EigenDA to subsidize L2 costs.
the-ethereum-roadmap-merge-surge-verge
Blog
Why On-Chain Storage Is Ethereum’s Bottleneck
The Merge and Surge address consensus and execution. The Verge tackles the fundamental, unsolved problem: exponential state growth. This is the analysis for builders.
introduction
THE STATE BOTTLENECK
The Merge Was Easy. The Surge Is Hard. The Verge Is Impossible.
Ethereum's scaling roadmap is blocked by the fundamental physics of on-chain data storage.
The Verge (Verkle Trees) is impossible because it requires a full state expiry mechanism that breaks every existing smart contract. No protocol like Uniswap or Aave can migrate without a hard fork.
Historical data is the anchor. Full nodes today store ~15TB. Post-Surge, this grows exponentially, centralizing infrastructure to professional services like Alchemy and Infura.
Evidence: A single 128KB blob on Ethereum adds ~$1 in cost. An L2 like Arbitrum needs thousands daily, making blob pricing the ultimate throttle on all scaling.
key-trends
WHY ON-CHAIN STORAGE IS ETHEREUM'S BOTTLENECK
The State of the State: Three Unavoidable Trends
Ethereum's state is the root of its scalability and cost issues, forcing a fundamental architectural rethink.
01
The Problem: State Growth is Unbounded and Expensive
Every new account and smart contract permanently increases Ethereum's state size, currently over 1 TB. This drives up hardware requirements for nodes and makes state access the primary cost for L2 rollups like Arbitrum and Optimism. The result is a ~$0.10+ base cost for simple transactions, pricing out micro-transactions and new users.
1 TB+
State Size
$0.10+
Base TX Cost
02
The Solution: Statelessness and State Expiry
The core protocol upgrade path. Stateless clients verify blocks using cryptographic proofs instead of storing full state, lowering node requirements. EIP-4444 (State Expiry) automatically archives unused state after ~1 year, capping active state growth. This is the endgame for Ethereum's scalability, but requires complex consensus changes and is ~3-5 years away.
~1 Year
Expiry Window
>90%
Node Cost Cut
03
The Interim Fix: Modular State Management
Projects are building stopgaps that Ethereum L1 lacks. EigenLayer restakers secure dedicated AVS chains for state storage. Celestia and Avail provide cheap, scalable data availability layers, shifting state burden off-chain. zkSync and Starknet implement native account abstraction with paymasters, externalizing state-related gas costs. This modular approach is winning now.
$10B+
Restaked TVL
-99%
DA Cost vs. L1
STATE SIZE ANALYSIS
The Bloat in Numbers: Ethereum State Growth Metrics
Quantifying the growth and impact of Ethereum's on-chain state, the primary bottleneck for node hardware and network decentralization.
| Metric | Ethereum Mainnet (Current) | Historical Growth (5-Year Trend) | Projected 5-Year Growth (Status Quo) |
|---|---|---|---|
Total State Size (GB) |
| ~250 GB to >1,200 GB |
|
Annual Growth Rate | ~40% | Peak: ~200% (2021) | ~40% (compounded) |
Full Sync Time (Fast) | ~15 hours | ~2 days (2020) |
|
Archive Node Storage | ~15 TB | ~3 TB to ~15 TB |
|
State Bloat Driver | Contract Storage (70%) | DeFi & NFT Booms | L2 Settlement & New Primitives |
Avg. Block State Delta | ~3 MB | ~0.5 MB to ~3 MB | ~10 MB |
Node RAM Requirement |
| 8 GB to > 32 GB |
|
Verkle Trees / EIP-6800 |
deep-dive
THE DATA
Why Storage, Not Compute, Is The Final Boss
The fundamental constraint for Ethereum's scalability is the cost and availability of on-chain state, not raw transaction processing power.
State growth is the bottleneck. Every new account, NFT, or DeFi position creates permanent on-chain data that all nodes must store forever. This state bloat increases hardware requirements, centralizes node operation, and makes historical data access slower.
Compute scales, storage does not. Layer 2s like Arbitrum and Optimism demonstrate that transaction execution can be massively parallelized off-chain. The final constraint is the data availability layer where this compressed data is posted, a problem solved by EigenDA and Celestia.
The cost is in the state, not the opcode. A simple ETH transfer costs gas because it updates two account balances in the global state trie. Expensive storage operations, not complex computation, dominate the gas costs for protocols like Uniswap and Aave.
Evidence: The Ethereum protocol's most significant recent upgrades, EIP-4844 (blobs) and the upcoming Verkle trees, are exclusively state management solutions. They address data bandwidth and storage efficiency, not execution speed.
protocol-spotlight
THE DATA COST CRISIS
Builder Reactions: How Protocols Are Adapting
Ethereum's state growth is a $10B+ existential threat to scalability. Here's how leading teams are engineering around it.
01
The Problem: Exponential State Bloat
Ethereum's full state grows by ~50 GB/year, forcing nodes into a centralizing hardware arms race. Every new contract, NFT mint, and wallet interaction adds permanent, globally replicated data that all nodes must store and process forever.
- Node Cost: Running an archive node now requires ~12+ TB of SSD storage.
- Sync Time: A full sync can take weeks, crippling network resilience.
- Gas Impact: ~20-30% of transaction gas is spent on state access and updates.
12+ TB
Archive Node Size
~30%
Gas for State Ops
02
The Solution: Statelessness & Verkle Trees
The core protocol's answer is to make execution clients stateless. Nodes would only need a tiny witness (~1.5 KB) for a block, not the full state. This is enabled by a shift from Merkle Patricia Tries to Verkle Tries.
- Node Relief: Enables lightweight nodes with near-instant sync.
- Scalability: Unblocks higher gas limits by removing state I/O bottlenecks.
- Timeline: A multi-year hard fork roadmap, with early testnets live.
~1.5 KB
Witness Size
>100M
Gas Limit Target
03
The Workaround: Rollups & Data Availability Layers
Builders aren't waiting. Rollups (Arbitrum, Optimism, zkSync) execute transactions off-chain and post only compressed data back to L1. This shifts the burden to specialized Data Availability (DA) layers like EigenDA, Celestia, and Avail.
- Cost Saving: ~90% reduction in on-chain data costs for rollups.
- Modular Future: Separates execution, settlement, consensus, and DA.
- EIP-4844 (Proto-Danksharding): Introduces blob storage for ~100x cheaper temporary rollup data.
-90%
Rollup Data Cost
100x
Cheaper w/ Blobs
04
The Pivot: Application-Specific Storage
Smart contracts are becoming storage-aware. Protocols like Uniswap V4 use singleton storage and transient storage to minimize slot writes. NFT projects use on-chain compression (Art Blocks) or fully migrate metadata to decentralized storage (IPFS, Arweave).
- Gas Efficiency: Singleton pattern can reduce pool creation cost by >99%.
- Permanent Storage: Arweave offers one-time, perpetual payment for data.
- Hybrid Models: Store critical logic on-chain, bulk data off-chain with cryptographic commitments.
>99%
Pool Create Savings
$0.02/GB
Arweave Cost (One-Time)
05
The Endgame: State Expiry & History Pruning
If state is too big, delete the unused parts. State expiry proposals aim to automatically "archive" state untouched for ~1 year, requiring a witness for reactivation. This requires robust history preservation networks like Portal Network or BitTorrent.
- Active State Cap: Could limit the "hot" state to ~100 GB, manageable for consumer hardware.
- Decentralized Archive: History becomes a separate, incentivized P2P service.
- User Experience: Wallets must manage state proofs for dormant assets.
~100 GB
Target Hot State
1 Year
Expiry Period
06
The Risk: Fragmentation & New Trust Assumptions
Every workaround introduces complexity. Using an external DA layer trades Ethereum's security for a new cryptoeconomic security model. Stateless clients rely on P2P networks for witness availability. History pruning risks data loss if archive networks fail.
- Security Dilution: A $1B staked DA layer is not the same as $80B+ staked Ethereum.
- Coordination Overhead: Developers now must choose a rollup, a DA layer, and a storage solution.
- Verification Burden: Light clients must verify proofs across multiple systems.
80x
Security Delta (ETH vs. DA)
Multi-Layer
Trust Stack
future-outlook
THE BOTTLENECK
The Path Through The Verge: Predictions for 2024-2025
Ethereum's scaling roadmap will stall unless on-chain storage costs are decoupled from execution.
The Verge's storage problem is existential. Verkle trees and stateless clients solve state growth for validators, but they do not reduce the blob storage cost for rollups. The current 128 KB per blob limit creates a hard cap on data availability, throttling L2 throughput.
EIP-4844 is a temporary fix. Proto-danksharding's blobs are cheaper than calldata, but they are not free. As L2 adoption grows, blob fee markets will spike, recreating today's high gas fee dynamics but at the data layer. This shifts, not solves, the bottleneck.
The solution is modular data availability. Ethereum's execution layer must offload historical data to specialized layers like EigenDA or Celestia. This creates a cost separation where execution pays for security, and storage pays for scalability. Rollups like Arbitrum and Optimism are already integrating these alternatives.
Evidence: The current blob capacity is ~0.375 MB per block. A single zk-rollup like StarkNet can saturate this during peak demand, forcing sequencers to compete. Without external DA, Ethereum L2s collectively cannot scale beyond ~27 TPS of sustained data posting.
takeaways
THE STORAGE BOTTLENECK
TL;DR for CTOs and Architects
Ethereon's execution layer is scaling, but its historical data layer is hitting fundamental limits of cost, speed, and decentralization.
01
The Problem: State Growth is Quadratic
Every new account and smart contract adds permanent, globally-accessible data. This leads to:\n- Exponential state bloat, currently ~1.5TB and growing.\n- Node hardware requirements skyrocket, centralizing consensus.\n- Sync times for new nodes stretch to weeks, harming liveness.
~1.5TB
State Size
Weeks
Sync Time
02
The Solution: Statelessness & EIP-4444
Decouple execution from full history storage. Clients only need recent state, not all history.\n- EIP-4444: Prunes historical data >1 year old from execution clients.\n- Portal Network: A decentralized, torrent-like P2P network for serving pruned history.\n- Node requirements drop from TBs to GBs, enabling consumer hardware.
>90%
Storage Cut
GBs
New Node Req.
03
The Bridge: Decentralized Storage Layers
EIP-4444's pruned data must live somewhere accessible. This creates a new infrastructure layer.\n- EigenDA & Celestia: Provide high-throughput data availability for rollups, reducing L1 calldata burden.\n- Arweave & Filecoin: Offer permanent, decentralized storage for historical archives.\n- Portal Network Clients: Become the lightweight query layer for this decentralized data.
$2B+
DA Market Cap
New Stack
Infra Layer
04
The Implication: Modular Data Markets
Execution, consensus, and data availability are formally separated. This creates competitive markets.\n- Rollups can choose DA layers based on cost/security (e.g., EigenDA vs Celestia).\n- Historical data becomes a retrievability service, not a consensus requirement.\n- Node operators specialize as block builders, proposers, or data servers.
10-100x
Cheaper DA
Specialized
Node Roles
05
The Risk: Data Availability Fragility
Splitting data from consensus introduces new failure modes and trust assumptions.\n- Data withholding attacks: A malicious DA layer can censor or withhold data, breaking fraud proofs.\n- Liveness vs. Safety: Optimistic rollups trade safety for liveness if DA is slow.\n- Bridging complexity: Proving data availability across layers adds latency and new cryptographic assumptions.
New Attack
Vector
Trusted
DA Assumption
06
The Architect's Playbook
Design for a post-4444 world where data is a service.\n- For L2s: Model costs for EigenDA, Celestia, and Ethereum calldata.\n- For dApps: Assume historical queries will be off-chain; integrate The Graph or custom indexers.\n- For Infrastructure: Build for the Portal Network or provide verifiable data services.
Cost Model
DA First
Off-Chain
Query Layer
ENQUIRY
Get In Touch
today.
Our experts will offer a free quote and a 30min call to discuss your project.
NDA Protected
Confidentiality24h Response
Time to ValueDirectly to Engineering Team
No Sales Fluff10+
Protocols Shipped
$20M+
TVL Overall