The Merge was a consensus upgrade. It changed how blocks are produced, not how data is processed. The exponential state growth remains the primary bottleneck for node operation and decentralization.
the-ethereum-roadmap-merge-surge-verge
Blog
Stateless Verification: Ethereum’s Next Baseline
The Merge and Surge get the headlines, but the Verge's stateless verification is the silent killer. This is the technical deep dive on solving Ethereum's state bloat to enable infinite L2 scaling.
introduction
THE BOTTLENECK
The Merge Was a Sideshow. State Growth is the Main Event.
Ethereum's fundamental scaling constraint is not consensus speed, but the exponential growth of the state that every node must store.
Statelessness is the only viable path. It decouples execution from state storage. Clients like Reth and Erigon are already building for this future, where validators only need a tiny witness, not the full state.
Verkle Trees enable stateless clients. They replace Ethereum's Merkle Patricia Tries with a single, efficient cryptographic proof. This reduces witness sizes from ~1 MB to ~150 bytes, making light client verification practical.
The real scaling unlocks here. Stateless verification enables trust-minimized bridges like Across and layerzero, secure light clients for rollups, and removes the hardware barrier for solo stakers. This is the foundation for the next 100x in throughput.
key-trends
STATELESS VERIFICATION
The State of the State: Three Unavoidable Trends
Ethereum's state is its greatest asset and its ultimate scaling bottleneck. Statelessness is the only viable path forward.
01
The Problem: State Bloat is a Security Tax
Full nodes must store the entire state (~1TB+) to validate blocks, creating prohibitive hardware requirements and centralization pressure.
- Security Cost: Fewer nodes = weaker network resilience.
- Validator Lock-In: High capital cost for hardware and storage.
- Throughput Ceiling: State growth directly limits block gas limit increases.
1TB+
State Size
<5K
Full Nodes
02
The Solution: Verkle Trees + Stateless Clients
Replace Merkle Patricia Tries with Verkle Trees, enabling stateless verification where validators only need a tiny proof (~150 bytes), not the full state.
- Client Efficiency: Node requirements drop from terabytes to gigabytes.
- Parallel Verification: Enables true scaling via EIP-4444 (history expiry).
- Foundation for The Verge: Essential for zk-EVM and Verkle-based L2s.
~150B
Witness Size
100x
Proof Efficiency
03
The Consequence: Redefining the L1-L2 Stack
Statelessness inverts the relationship between execution and settlement. L1 becomes a pure verification hub, while L2s and rollups handle state execution.
- L1 as Settlement Layer: Focus on DA and proof verification.
- L2 Sovereignty: Can manage their own state models (e.g., Fuel, Aztec).
- New Primitives: Enables universal state channels and light client bridges.
0-State
L1 Goal
L2-Centric
Ecosystem
deep-dive
THE BASELINE
Deconstructing the Verge: From Stateful to Stateless
Stateless verification is the required architectural shift to scale Ethereum's consensus layer without compromising decentralization.
Stateless verification replaces full state storage with cryptographic proofs. Nodes validate blocks using a Verkle proof instead of holding the entire 1TB+ state, eliminating the primary bottleneck to solo staking.
The Verge upgrade is not optional scaling. It is the prerequisite for en-route sharding and peerDAS, which require nodes to efficiently verify data from other shards they do not store.
Verkle Trees vs. Merkle Patricia Tries compress proof sizes from ~300KB to ~150 bytes. This orders-of-magnitude reduction enables stateless clients on consumer hardware, directly enabling Ethereum's PBS roadmap.
Evidence: Post-Verge, a validator's hardware requirement drops from needing a 2TB NVMe to a 500GB SSD. This hardware floor reduction is the concrete metric for decentralized scaling.
STATELESS VERIFICATION
The Node Burden: State Growth vs. Verification Cost
Comparison of Ethereum's current stateful execution with the proposed stateless verification paradigm, analyzing the trade-offs in node resource requirements and network security.
| Core Metric / Capability | Current Stateful Execution | Stateless Verification (Verkle Trees) | Stateless Clients (Portal Network) |
|---|---|---|---|
State Size Growth (Annual) | ~200 GB | ~50 GB (witness data) | 0 GB (client holds no state) |
Minimum Node Storage |
| ~100 GB SSD | < 50 GB SSD |
Block Verification Cost (Bandwidth) | ~1-2 MB/block | ~250-500 KB/block + witness | ~250-500 KB/block + witness |
Synchronization Time (Full Archive) | ~1-2 weeks | ~2-3 days | < 1 day (light client) |
Requires Execution State for Validation | |||
Trust Assumption for Data | None (full validation) | None (cryptographic proof) | 1-of-N honest Portal node |
Primary Bottleneck | Storage I/O & RAM | Witness Size & Bandwidth | Network Latency for Proofs |
Implementation Timeline | Live | Post-Prague/Electra (2025+) | Incremental rollout with Portal Network |
counter-argument
THE VERIFIER'S DILEMMA
The Devil's Advocate: Is This Just Kicking the Can?
Stateless verification shifts the state burden but introduces new trust and data availability trade-offs.
Statelessness is a trade-off, not a panacea. It eliminates the need for validators to store full state, but the data availability problem simply moves to a different layer. Clients must still source and verify state proofs, creating a new dependency on sufficiently decentralized data networks like EigenDA or Celestia.
The trust model morphs. Instead of trusting a node's state integrity, you now trust the cryptographic soundness of the proof system (e.g., Verkle proofs) and the liveness of the data availability layer. This is a different, potentially more brittle, oracle-like dependency for the base layer.
Execution clients become specialized. The general-purpose Ethereum node disappears. Light clients using ZK proofs or Verkle trees are efficient but require constant, reliable access to external data. This centralizes client development around a few teams that can manage this complexity, like Nethermind or Erigon.
Evidence: The current bottleneck. Today's light clients rely on centralized RPC providers like Infura. Stateless verification's success hinges on decentralized proof markets and peer-to-peer data networks emerging at scale, which remain unproven for Ethereum's security requirements.
protocol-spotlight
FROM THEORY TO PRODUCTION
The Builders: Who's Making Statelessness Real?
Stateless verification is moving from academic papers to live infrastructure. These are the teams building the primitives that will define Ethereum's next performance baseline.
01
Ethereum's Verkle Trees: The State Commitment Overhaul
The core protocol upgrade replacing Merkle Patricia Tries. It's the prerequisite for stateless clients by enabling small, constant-sized proofs (~150 bytes) for any state access.
- Enables Statelessness: Clients verify blocks without storing the multi-terabyte state.
- Constant Proof Size: Proof size is independent of state size, enabling light clients with ~1 MB of data.
- Paves Way for The Verge: A key milestone in Ethereum's endgame scaling roadmap.
~150B
Proof Size
1 MB
Client Footprint
02
RISC Zero: General-Purpose zkVM for State Transitions
A zero-knowledge virtual machine that can generate succinct proofs for arbitrary computations, including full EVM execution. This turns state transition verification into a cryptographic proof-checking problem.
- Universal Proof Layer: Can prove execution of Rust, C++, Solidity, enabling Ethereum L1 and L2 stateless verification.
- Offloads Work: Provers generate proofs; validators only verify, reducing node requirements.
- Bonsai Network: A decentralized network for proof generation, abstracting complexity.
zkEVM
Use Case
Decentralized
Prover Net
03
Succinct Labs & SP1: The zkVM Performance Frontier
Building SP1, a high-performance zkVM focused on ultra-fast proving times for core infrastructure, directly competing with RISC Zero on performance and cost.
- Performance Focus: Aims for ~10x faster proving for cryptographic primitives vs. alternatives.
- Targets Core Infra: Optimized for proving consensus (Light Client), bridges, and EigenLayer AVSs.
- Telepathy Protocol: A live product offering trust-minimized cross-chain messaging using zk light clients.
10x
Faster Proving
AVS Ready
EigenLayer
04
The Lagrange Labs: Parallel zk Proofs for Mass Data
Specializes in zkMapReduce, a paradigm for proving large-scale state computations (like historical data aggregation) with parallel proving. This is statelessness for data analytics and light client sync.
- Proves State History: Generates proofs for historical state transitions or cross-chain state, not just the latest block.
- Parallel Proving: Scales proof generation across many machines, tackling terabyte-scale state.
- Unlocks New Primitives: Enables trustless indexing, oracle state proofs, and one-shot light client sync.
Parallel
Architecture
TB Scale
Data Proven
05
Avail & Celestia: Data Availability as a Stateless Primitive
While not 'stateless verification' in the Ethereum sense, they provide the critical Data Availability (DA) layer. Stateless validators need guaranteed access to transaction data, which these modular chains provide.
- Offloads Blobs: Moves ~100 KB blob data off L1, reducing Ethereum's load.
- Enables L2 Statelessness: Rollups can post data cheaply to Avail/Celestia, then prove knowledge of it on Ethereum.
- Foundation for Validiums: The security model for zk-rollups that don't post data to L1.
~100KB
Blob Cost
Validium DA
Use Case
06
The Pragmatic Path: PBS & MEV-Boost as Precursors
Proposer-Builder Separation (PBS) and MEV-Boost are live today, creating a market where specialized builders construct full blocks. This is a functional separation of state that paves the way for stateless consensus.
- Separates Roles: Proposers (validators) choose headers, builders assemble full state.
- Incentivizes Builders: Creates economic incentive for entities to run full nodes, maintaining state.
- Smooths Transition: Allows the network to gradually adopt stateless validation without a hard cutover.
>90%
Eth Blocks
Live Now
Status
future-outlook
THE VERIFICATION LAYER
The Baseline: A World of Ultra-Light Clients and Sovereign Rollups
Stateless verification transforms Ethereum into a universal settlement layer for sovereign execution environments.
Statelessness is the prerequisite for a world of ultra-light clients. It replaces full-state storage with cryptographic proofs, enabling trust-minimized verification on resource-constrained devices. This shifts the baseline from storing data to verifying proofs.
Sovereign rollups are the primary beneficiaries. Unlike smart contract rollups, they post data to Ethereum but settle disputes off-chain. Statelessness lets them use Ethereum purely for data availability and proof verification, not execution.
This creates a new verification market. Projects like EigenLayer and Avail compete to provide the cheapest, most secure data and proof verification layer. The winning standard becomes the internet's trust root.
Evidence: An Ethereum stateless client requires ~1 MB of data versus today's ~1 TB full node. This 1,000,000x reduction enables verification on mobile devices.
takeaways
STATELESS VERIFICATION
TL;DR for Busy Builders
Ethereum's stateless future shifts the state burden from nodes to clients, unlocking a new scaling paradigm. Here's what it means for your stack.
01
The Problem: State Growth Chokes Nodes
Ethereum's state is ~200GB and growing, forcing nodes to use high-end SSDs and limiting decentralization. This is the primary bottleneck for scaling L1 execution.
- Hardware Requirements escalate, pricing out home validators.
- Sync Times for new nodes stretch to weeks, harming network resilience.
- Bandwidth Costs for state access dominate operational overhead.
~200GB
State Size
Weeks
Sync Time
02
The Solution: Verkle Trees + Witnesses
Replaces Merkle Patricia Tries with Verkle Trees (vector commitments). Clients no longer store state; they receive a cryptographic witness proving specific state elements.
- Constant-Size Witnesses (~150 bytes) regardless of state depth.
- Enables Stateless Clients, reducing node requirements to ~1TB SSD and 50 Mbps bandwidth.
- Paves the way for EIP-4444 (history expiry) and full stateless validation.
~150B
Witness Size
1TB SSD
Node Req
03
The Builder Impact: Hyper-Scaled L2s & New Primitives
Statelessness is the bedrock for Verkle-based L2s (e.g., Kakarot, Polygon zkEVM) and unlocks novel architectures. Your rollup's proving system can now assume a stateless parent chain.
- ZK Rollups benefit from simpler state proofs and cheaper verification.
- Optimistic Rollups gain faster, cheaper fraud proof dissemination.
- Enables account abstraction wallets and single-slot finality designs.
10x+
L2 Throughput
-90%
Proof Cost
04
The Catch: Bandwidth is the New Bottleneck
Statelessness trades storage for bandwidth. Every transaction must now propagate with its witness, increasing initial payload size. This shifts the scaling challenge to the P2P network layer.
- Gossip protocol must be redesigned (see EIP-7069).
- Relay networks and sufficient peers become critical infrastructure.
- Witness aggregation (e.g., SNARK'd witnesses) is the next research frontier.
~1-2 KB
Tx+Witness
P2P
New Focus
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