Stateless Client Enabler: Verkle Trees replace Merkle Patricia Tries to make state proofs small enough for stateless clients. This allows validators to verify blocks without storing the entire 1TB+ state, a prerequisite for scaling node count.
the-ethereum-roadmap-merge-surge-verge
Blog
Why Verkle Trees Change Ethereum State Proofs
Verkle Trees replace Ethereum's Merkle Patricia Tries, collapsing proof sizes from ~300KB to ~150 bytes. This technical deep dive explains the first-principles mechanics, the impact on stateless clients and light clients, and why it's the linchpin for the Verge.
introduction
THE STATE PROOF BOTTLENECK
Introduction
Verkle Trees are a cryptographic upgrade that fundamentally re-architects how Ethereum stores and proves state, enabling stateless clients and scaling block verification.
Witness Size Collapse: The key innovation is vector commitments over Merkle proofs. A proof for 1,000 accounts compresses from ~1 MB to ~150 KB, making it feasible to include in every block for protocols like The Graph or cross-chain bridges.
ZK-SNARK Synergy: Tiny proofs are essential for ZK-rollups like StarkNet and zkSync. Verkle Trees allow ZK circuits to efficiently prove state transitions, reducing the computational overhead for L2 validity proofs.
Evidence: Current Ethereum state growth is ~50 GB/year. Without Verkle Trees, the hardware requirements for a full node become prohibitive, centralizing the network and crippling light client adoption for wallets like MetaMask.
key-trends
THE DATA STRUCTURE SHIFT
The State Proof Bottleneck: Why MPTs Fail
Ethereum's Merkle Patricia Trie (MPT) is a foundational but flawed data structure that creates a critical bottleneck for statelessness and scaling.
01
The Problem: Witness Size Explosion
MPT proofs (witnesses) for state access grow linearly with tree depth, becoming massive. This makes stateless clients and light clients impractical.
- Witness size for a simple transfer can be ~1-3 kB.
- Stateless validation would require propagating ~1 MB+ of proofs per block, crippling p2p networks.
~1 MB+
Proof Per Block
Linear
Growth
02
The Solution: Vector Commitments & Verkle Trees
Verkle Trees replace hashes with vector commitments (using polynomial commitments like KZG). This allows for constant-size proofs regardless of tree depth or data location.
- Proof size collapses to ~150-200 bytes.
- Enables practical stateless clients and witness sizes that fit in a single packet.
~200 B
Proof Size
Constant
O(1) Proofs
03
The Architectural Win: Statelessness Unlocked
With tiny proofs, the entire network paradigm shifts. Validators no longer need to store state, reducing hardware requirements and centralization pressure.
- Node requirements drop from ~2 TB SSD to potentially ~100s of GB.
- Enables ultra-light clients with trust-minimized access, challenging centralized RPC providers like Infura and Alchemy.
>90%
State Storage Cut
Radical
Decentralization
04
The Ripple Effect: L2s & Cross-Chain
Efficient state proofs are the bedrock for seamless interoperability. Verkle proofs make light client bridges (e.g., to Ethereum L2s like Arbitrum, Optimism) and intent-based systems (UniswapX, Across) far more viable.
- Reduces latency and cost for cross-chain messaging (LayerZero, Chainlink CCIP).
- Strengthens security of rollup fraud/validity proofs by simplifying state verification.
Cheaper
L2 Bridges
Stronger
Proof Security
STATEFULNESS AT SCALE
Proof Size Comparison: MPT vs. Verkle Tree
Quantifies the cryptographic overhead reduction for Ethereum state proofs, enabling stateless clients and light clients.
| Proof Characteristic | Merkle Patricia Trie (Current) | Verkle Tree (Verkle EIP) | Implication |
|---|---|---|---|
Witness Size for Single Account Proof | ~3 KB | ~150 Bytes | ~95% reduction enables p2p network propagation |
Witness Nodes Required (Depth) | ~7-9 Hashes | 1 Vector Commitment | Constant-size proof independent of tree depth |
Proof Aggregation Capability | Enables batch validity proofs for rollups (e.g., StarkNet, zkSync) | ||
Cryptographic Primitive | Keccak-256 (Hash) | Pedersen Commitment + IPA (ECC) | Enables polynomial commitments for SNARK/STARK compatibility |
Bandwidth for Light Client Sync | ~1-2 MB | < 20 KB | Enables phone-based light clients (e.g., Helios, Nimbus) |
State Growth Impact on Proof Size | Logarithmic (O(log n)) | Constant (O(1)) | Future-proofs Ethereum against unbounded state bloat |
Required for Stateless Validation | Core enabler for The Purge, eliminating historical state from execution clients | ||
Compatibility with Existing State | Native | Requires One-Time Migration (Verkle Trie) | Major hard fork event, akin to the Merge or Shanghai |
deep-dive
THE STATE PROOF BOTTLENECK
Deep Dive: The Cryptography Behind the Compression
Verkle Trees replace Merkle Patricia Tries to make Ethereum state proofs small enough for stateless clients and Layer 2s.
Merkle proofs are too large. A simple balance proof in Ethereum's current tree is ~1KB, making stateless validation and Layer 2 data compression impractical for mass adoption.
Verkle Trees use vector commitments. They replace Merkle hashes with polynomial commitments (KZG), collapsing proof size from ~1KB to ~150 bytes regardless of tree depth.
This enables stateless clients. Nodes verify blocks without storing the 150GB+ state, downloading tiny proofs instead. This is foundational for zkEVM scaling and light client viability.
Witness sizes collapse for L2s. Optimistic rollups like Arbitrum and Optimism can post cheaper, compressed state diffs. zkRollups like zkSync and Starknet generate more efficient validity proofs.
Evidence: The current Merkle proof for an account is ~1KB. A Verkle proof for the same data is ~150 bytes, a ~85% reduction critical for bandwidth-constrained environments.
protocol-spotlight
STATE PROOF REVOLUTION
The Verge Ecosystem: What Unlocks Post-Verkle
Verkle Trees are not an incremental upgrade; they are a fundamental re-architecture of Ethereum's state that enables a new class of light clients and statelessness.
01
The Problem: Statelessness Was a Fantasy
Pre-Verkle, a 'stateless client' needed to download a ~1 MB witness for a simple transfer. This was a non-starter for mobile or browser clients, keeping Ethereum's security model dependent on centralized RPCs like Infura and Alchemy.
- Old Witness Size: ~1 MB per tx
- Client Requirement: Full nodes or trusted RPCs
- Bottleneck: Merkle-Patricia Tree depth & proof size
~1 MB
Old Witness
0
Mobile Viability
02
The Solution: Sub-1 KB Witness Proofs
Verkle Trees use vector commitments (like IPA/KZG) to collapse proof paths. A complex Uniswap swap proof shrinks from megabytes to kilobytes, making stateless verification feasible for the first time.
- New Witness Size: ~150 bytes for simple tx
- Enables: True stateless clients, Portal Network viability
- Impact: Breaks RPC oligopoly, enables trust-minimized light clients
~150B
New Witness
>1000x
Improvement
03
The Unlock: Portal Network & The Super Light Client
With tiny proofs, the Portal Network (a decentralized peer-to-peer light client network) becomes practical. This enables a new security model where wallets like MetaMask can verify chain data directly, eliminating trust in RPC providers.
- Direct Access: Clients sync state via P2P, not centralized APIs
- Security Model: Inherits L1 consensus security, not Infura's uptime
- Ecosystem Shift: Enables ZK-Bridges (like Succinct) and L2 light clients to be radically cheaper and simpler.
P2P
New Sync
L1 Security
For Wallets
04
The Killer App: Vaporware Becomes Viable
Projects waiting for feasible statelessness can now launch. This includes fully on-chain games (like Dark Forest), mass-scale social graphs, and permissionless L2 bridges that don't rely on multisigs.
- On-Chain Games: State updates with sub-second proof sync
- L2 Bridges: Ethereum-native light clients replace trusted committees (see Succinct, Herodotus)
- Developer UX: Contracts can assume cheap, verifiable state access from any client.
Viable
On-Chain Apps
Native
L2 Security
05
The Infrastructure Shift: Reth & Erigon Win
Client teams that implemented Verkle early (like Reth and Erigon) gain a structural advantage. Their architectures are built for parallel witness generation and stateless execution, making them the go-to for high-throughput RPC providers and L2 sequencers.
- Performance: Parallel proof generation for sequencers (e.g., Arbitrum, Optimism)
- Market Shift: Infrastructure competition moves from 'who has the API' to 'who has the fastest proving stack'.
- New Biz Model: Providers can offer verified state endpoints as a premium service.
Parallel
Proof Gen
New Biz Model
For RPCs
06
The Endgame: Ethereum as a Universal Settlement Proof
Verkle Trees finalize Ethereum's transition to a proof-based system. With tiny, universal state proofs, Ethereum becomes the optimal verification layer for everything: Bitcoin via bridges, Cosmos zones, and real-world data oracles.
- Universal Verifier: Any chain's state can be proven on Ethereum cheaply (see Polygon zkEVM, zkSync)
- Data Availability: Coupled with EIP-4844 blobs, creates a full stack for sovereign rollups.
- Final Vision: A network where security is cryptographic, not social, enabling ~1 million TPS via L2s.
Universal
Settlement
~1M TPS
L2 Capacity
counter-argument
THE VERIFIER'S DILEMMA
Counter-Argument: The Complexity & Trust Trade-off
Verkle trees introduce cryptographic complexity that shifts the trust burden from data availability to proof verification.
Verkle proofs are smaller but require more complex cryptography. This replaces the Merkle-Patricia Trie's simple hashing with KZG polynomial commitments and IPA proofs. The state proof size drops from ~1 MB to ~150 bytes, but verifying it demands a new, less battle-tested cryptographic stack.
The trust model inverts. Light clients no longer trust block headers for data availability; they trust the cryptographic soundness of the proof system. This moves the attack surface from network-level data withholding to potential, albeit unlikely, mathematical vulnerabilities in the KZG/IPA constructions.
This complexity creates a client burden. Teams like Geth and Nethermind must implement and maintain this new cryptographic layer. The risk is not a broken primitive, but implementation bugs in complex code, a lesson learned from the BN254 pairing curve audit history.
Evidence: A Verkle witness for a full Ethereum state is ~200 MB, versus the impossible multi-gigabyte witness for a Merkle tree. The trade-off is explicit: manageable data for provers, but higher verification logic complexity for all clients.
FREQUENTLY ASKED QUESTIONS
Verkle Trees FAQ: For Architects & Builders
Common questions about why Verkle Trees fundamentally change Ethereum state proofs and what it means for developers.
A Verkle Tree is a cryptographic data structure that will replace Ethereum's Merkle Patricia Trie for storing state. It uses vector commitments to create much smaller state proofs, enabling stateless clients and resolving the 'state growth' problem that currently burdens node operators.
takeaways
VERKLE TREES & STATE PROOFS
TL;DR: Key Takeaways for Builders
Verkle Trees are a fundamental data structure upgrade that redefines how Ethereum clients prove and access state, enabling statelessness and radical scaling.
01
The Problem: Witness Size Kills Statelessness
Merkle Patricia Trie proofs are massive (~1MB), making stateless clients and light clients impractical. This bottleneck prevents scaling block validation and network participation.
- Merkle Proofs for a simple transfer are ~1-2KB.
- A full block's witness can be ~1MB, exceeding block gas limits.
- This forces nodes to store the entire state, centralizing the network.
~1MB
Witness Size
>99%
Reduction Target
02
The Solution: Vector Commitments & KZG Proofs
Verkle Trees replace hashes with KZG polynomial commitments, allowing for constant-size proofs regardless of tree depth. This is the cryptographic breakthrough that enables statelessness.
- Proof size collapses to ~150 bytes per witness.
- Enables stateless validators that don't store state.
- Makes light clients viable for secure, trust-minimized access (like The Graph or L2 provers).
~150B
Proof Size
O(1)
Verification
03
The Impact: Unlocking Stateless Ethereum
With tiny proofs, the entire network architecture shifts. Validators become stateless, lowering hardware requirements from ~2TB SSDs to potentially ~1GB RAM. This radically decentralizes node operation.
- Node requirements drop from enterprise-grade to consumer hardware.
- Enables single-slot finality by making block propagation faster.
- L2s like Arbitrum and Optimism can submit cheaper, more efficient state proofs.
~1GB
Node RAM
~500ms
Proof Verify
04
The Builder's Edge: New Primitives & Tooling
Verkle Trees aren't just an infra upgrade; they're a new primitive. Builders can design protocols assuming cheap, ubiquitous state proofs.
- ZK-Rollups (e.g., zkSync, Scroll) get cheaper proof aggregation.
- Cross-chain apps can use ultra-light clients for bridging (cf. LayerZero, IBC).
- New account abstraction and storage models become feasible (see ERC-4337, ERC-7579).
New
Primitives
10x
Dev UX
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