Ethereum's state is expensive. The EVM's global shared state is the root of its security and its scaling constraint. Every full node must store and process this state, making permanent data the network's most precious resource.
the-ethereum-roadmap-merge-surge-verge
Blog
Ethereum Storage and the Cost of Simplicity
Ethereum's elegant Merkle-Patricia Trie enabled a world computer but created a state growth crisis. The Verge upgrade, with Verkle trees and statelessness, is the necessary, complex fix for its simple design.
introduction
THE DATA
The Elegant Bottleneck
Ethereon's storage model is a deliberate trade-off, creating a predictable cost for global consensus that every scaling solution must navigate.
Calldata is the canonical cost layer. L2s like Arbitrum and Optimism use Ethereum as a data availability (DA) layer, posting compressed transaction batches as calldata. This creates a direct, verifiable link between L2 activity and L1 gas costs.
The bottleneck is intentional. This design forces a publicly auditable cost model for scaling. Unlike alt-L1s with opaque validator hardware requirements, Ethereum's gas fees transparently price global state bloat, making L2 economics predictable.
Evidence: The EIP-4844 proto-danksharding upgrade is the canonical response. It introduces blob-carrying transactions, a dedicated data lane for L2s that is cheaper than calldata but still ephemeral, preserving the core economic constraint while improving throughput.
key-trends
ETHEREUM STORAGE AND THE COST OF SIMPLICITY
The State of State: Three Unavoidable Trends
Ethereum's elegant state model is buckling under its own success, forcing a fundamental re-architecture of data storage and access.
01
The Problem: State Growth is a $50B+ Subsidy
Every full node must store the entire state (~1.5TB and growing), a cost socialized across the network. This creates a centralizing force and a hard cap on validator growth. The economic model is broken: users pay a one-time fee for perpetual storage.
- State bloat grows at ~50 GB/month.
- Running a full node requires enterprise-grade hardware.
- The security subsidy is unsustainable for a global settlement layer.
1.5TB+
State Size
~50B
Implicit Subsidy
02
The Solution: Verkle Trees & Statelessness
Ethereum's core upgrade path replaces Merkle Patricia Tries with Verkle Trees, enabling stateless clients. Validators no longer need to store state; they verify proofs. This is the prerequisite for mass node decentralization.
- Proof sizes shrink from ~1KB to ~150 bytes.
- Enables light clients with full security.
- Paves the way for state expiry, moving historical data to a separate tier.
150B
Proof Size
1000x
Node Scalability
03
The Trend: Modular State & Specialized DA
The future is modular state layers. Execution layers (rollups) outsource data availability to specialized layers like Celestia, EigenDA, and Avail. This creates a competitive market for data storage, decoupling it from execution.
- Costs drop from ~$100 per MB (calldata) to <$1 per MB.
- Enables high-throughput app-chains and sovereign rollups.
- Ethereum's role shifts to consensus and settlement, not raw data storage.
-99%
DA Cost
Modular
Architecture
deep-dive
THE STORAGE BOTTLENECK
From Merkle to Verkle: Anatomy of a Fix
Ethereum's state growth is unsustainable, and its current Merkle Patricia Trie is the root cause of its scaling and decentralization crisis.
Merkle Patricia Tries are inefficient. They require storing all intermediate nodes to prove any single piece of data, causing state bloat that forces node operators to use expensive SSDs and high-bandwidth connections.
Verkle Trees use vector commitments. This cryptographic primitive allows a single, small proof to verify any number of values, collapsing the proof size from kilobytes to bytes and enabling stateless clients.
Statelessness is the endgame. Clients no longer need to store the entire state; they verify block execution using compact proofs, lowering hardware requirements and preserving decentralization. This is a prerequisite for Verkle-based light clients and full zk-EVM adoption.
The fix is non-negotiable. Without Verkle trees, Ethereum's state size grows quadratically with usage, making solo staking and running a Geth or Nethermind node prohibitively expensive, centralizing the network.
ETHEREUM'S STATE TRIE EVOLUTION
Storage Regimes: MPT vs. Verkle Trees
A technical comparison of Ethereum's current Merkle Patricia Trie (MPT) and the proposed Verkle Tree structure, focusing on the trade-offs between proven simplicity and future scalability.
| Feature / Metric | Merkle Patricia Trie (MPT) | Verkle Tree (Proposed) |
|---|---|---|
Proof Size (for 1000 accounts) | ~3 KB | < 150 bytes |
Witness Complexity | O(k logₖ n) - Sibling hashes per level | O(1) - Constant-size proof |
State Sync Speed (Full Node) | Hours to days (syncs entire state) | Minutes (syncs via stateless proofs) |
Gas Cost for Storage Op (SLOAD) | 2100 gas (cold), 100 gas (warm) | Projected ~80% reduction |
Cryptographic Primitive | Keccak-256 (SHA-3) | Pedersen Commitments & KZG Polynomials |
Stateless Client Support | ||
In-Protocol Since | Frontier (2015) | Prague/Electra Upgrade (Target 2025) |
Key Dependency | Database I/O (LevelDB, RocksDB) | Vector Commitments (math proofs) |
counter-argument
THE STORAGE TRAP
The Complexity Tax: Is The Cure Worse Than The Disease?
Ethereum's state growth is an existential cost that forces complexity onto L2s and users.
Ethereum's state bloat is a direct subsidy for L1 security, paid by every L2. Each byte stored on-chain creates a permanent, compounding cost for all future nodes. This forces rollups like Arbitrum and Optimism into complex, off-chain data management schemes to avoid this tax.
The 'simple' L1 externalizes its complexity. Ethereum's design pushes data availability, execution, and proving complexity onto L2s and bridges like zkSync and StarkNet. The base layer's simplicity is a mirage; the system's total complexity has simply been redistributed upward.
Witness the gas market. High L1 calldata costs, which directly impact L2 fees, are the market pricing this storage tax. Proposals like EIP-4844 (blobs) and danksharding are admissions that the current cost model is unsustainable for scaling.
Evidence: The Celestia and EigenDA ecosystems exist because developers are voting with their capital for alternative data availability layers, explicitly rejecting Ethereum's cost structure for non-security-critical data.
takeaways
ETHEREUM STORAGE AND THE COST OF SIMPLICITY
Architectural Implications
Ethereum's monolithic design prioritizes security and simplicity, but its storage model imposes fundamental constraints on scalability and cost.
01
The State Bloat Problem
Every account and smart contract's data is stored permanently on-chain, leading to exponential state growth. This burdens all nodes, centralizing infrastructure and inflating gas costs for basic operations.
- Key Constraint: State size grows ~50 GB/year, requiring >2 TB SSDs for archive nodes.
- Architectural Tax: Simple
SSTOREoperations can cost >20k gas, pricing out dense on-chain applications.
>2 TB
Archive Node
20k+ gas
Base SSTOREs
02
Statelessness & Verkle Tries
The solution is to decouple execution from storage. Verkle Tries enable stateless clients, where validators only need a tiny proof (~150 bytes) of state, not the entire database.
- Node Relief: Full nodes could sync in minutes, not weeks, on consumer hardware.
- Scalability Foundation: Enables >100k TPS execution layers (e.g., EigenDA, zkRollups) without burdening L1 consensus.
~150 B
Witness Size
>100k TPS
Potential
03
The Modular Storage Stack
Persistent data is migrating off the execution layer. Ethereum becomes a settlement and data availability (DA) layer, while specialized systems handle storage.
- DA Layers: Celestia, EigenDA, Avail provide cheap blob space (~$0.01 per 125 KB).
- Execution Layers: Rollups (Arbitrum, Optimism) and L2s use this DA, pushing state growth off L1.
~$0.01
Per Blob Cost
125 KB
Blob Size
04
EIP-4844 & Blob-Carrying Transactions
Proto-danksharding introduced a separate fee market for data. Blobs are cheap, ephemeral storage (~18 days) designed for rollup data, decoupling L2 transaction costs from mainnet congestion.
- Cost Decoupling: L2 fees dropped >90% post-EIP-4844.
- Future-Proofing: Paves way for full danksharding, scaling blobs to ~16 MB per block.
>90%
L2 Fee Drop
~18 days
Blob Persistence
05
The Endgame: Execution-Centric L1
Ethereum's long-term role shifts exclusively to high-value settlement and verification. Storage and complex execution are delegated, preserving L1's security while enabling hyper-scalability.
- Pure Function: L1 validates proofs, orders transactions, and ensures DA.
- Innovation Layer: Enables new paradigms like intent-based systems (UniswapX, CowSwap) and sovereign rollups without L1 state overhead.
Settlement
Primary Role
Proofs & DA
Core Service
06
The Alt-L1 Tradeoff
Chains like Solana and Sui attempt monolithic scaling with optimized storage (e.g., Solana's concurrent state access). This achieves low fees now but faces the same state growth asymptote, risking future centralization or forced modularization.
- Short-Term Win: ~$0.001 transaction costs and ~400ms finality.
- Long-Term Risk: State growth may necessitate similar modular splits, replicating Ethereum's path.
~$0.001
Tx Cost
~400ms
Finality
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