State growth is the real bottleneck. Block size and gas limits constrain throughput, but the unbounded expansion of the state database cripples node sync times and centralizes hardware requirements.
the-ethereum-roadmap-merge-surge-verge
Blog
State Witnesses: The Core of Stateless Ethereum
Stateless Ethereum promises radical node scaling. Its core innovation isn't a new data structure, but the cryptographic proof that makes it usable: the state witness. We break down why witnesses are the linchpin of The Verge.
introduction
THE CORE CONSTRAINT
Introduction: The Scaling Bottleneck Isn't Blocks, It's State
Ethereum's primary scaling limit is the exponential growth of its global state, not its transaction throughput.
Statelessness is the architectural shift. Instead of nodes storing the entire state, they verify transactions using cryptographic proofs called state witnesses. This decouples validation from storage.
Verkle Trees enable this future. Ethereum's current Merkle-Patricia Trie is inefficient for proof generation. The shift to Verkle Trees, with their constant-sized proofs, is the prerequisite for stateless clients.
Evidence: A full Ethereum archive node requires over 12TB of storage. Without statelessness, this requirement grows linearly with adoption, making solo staking and light clients unsustainable.
thesis-statement
THE CRYPTOGRAPHIC GLUE
Thesis: Witnesses Are the Bridge Between Statelessness and Execution
State witnesses are the compact, verifiable proofs that enable stateless clients to execute transactions without storing the entire blockchain state.
Statelessness requires cryptographic proofs. A stateless client discards the multi-terabyte state trie, relying instead on a state witness—a Merkle proof—to verify the specific data needed for a transaction.
Witness size is the bottleneck. The naive approach generates proofs of several hundred kilobytes per block. This is why Verkle Trees and EIP-3102 are essential; they compress witness size by an order of magnitude.
Witnesses separate validation from storage. This architectural shift mirrors how zk-rollups like zkSync or StarkNet operate: execution nodes handle proofs, while a decentralized network of provers and attesters ensures data availability.
The endgame is universal light clients. A successful witness standard enables Portal Network clients to securely sync in seconds, making Ethereum's security portable to mobile devices and other chains.
key-trends
STATELESSNESS PRIMER
The State of The State: Why Witnesses Are Non-Negotiable
Statelessness is Ethereum's endgame for scalability, but it requires a fundamental shift from storing state to verifying proofs of it.
01
The 1 TB Node Problem
Full Ethereum state is approaching 1 TB, creating centralization pressure. Stateless clients shift the burden from storage to verification.
- Eliminates the need for nodes to store the entire state trie.
- Enables lightweight clients with ~100 MB of data.
- Decentralizes validation, moving away from a few large infrastructure providers.
1 TB
State Size
~100 MB
Client Target
02
Verkle Trees vs. Merkle-Patricia
The current Merkle-Patricia Trie requires massive ~1 MB witnesses. Verkle Trees, using polynomial commitments, shrink proofs to ~150 bytes.
- Enables practical stateless validation for block propagation.
- ~1000x reduction in witness size is the key unlock.
- Directly enables EIP-6800 (Verkle Trees for Ethereum).
~150 B
Verkle Proof
1000x
Size Reduction
03
Witness as a Universal Abstraction
A state witness is a proof of inclusion/exclusion. This abstraction is foundational for zk-EVMs, light clients, and cross-chain.
- zkSync Era and Scroll generate validity proofs for state transitions, a super-witness.
- Portal Network clients use witnesses for trust-minimized access.
- Unifies verification across L1, L2, and bridges like LayerZero.
Universal
Abstraction
Core Primitve
For L2 & L1
04
The Gas Cost Bottleneck
Without statelessness, accessing state in EVM is a major gas cost driver. Witnesses allow pre-paid and pre-verified state access.
- EIP-2930 (Access Lists) was a first step to reduce inefficiency.
- Future: Provers can batch witness generation, amortizing cost.
- Enables new fee market dynamics for state-heavy operations.
Major
Gas Driver
Amortized
Future Cost
05
Statelessness Enables Stateless Rollups
Today's rollups (Optimism, Arbitrum) are stateful, requiring full nodes. Stateless Ethereum enables truly light verifier nodes for rollups.
- Rollup verifiers only need the witness, not the full L2 state.
- Drives ~10x+ reduction in operational overhead for node runners.
- Final piece for the modular stack: decentralized, cheap verification.
Light
Verifier Nodes
10x+
Ops Reduction
06
The Endgame: Client Diversity via Specialization
Witnesses allow clients to specialize. One client verifies execution, another data availability, another bridges—all using the same proof format.
- Breaks monolithic client software into modular components.
- Ethereum Execution Layer becomes a verification hub.
- Critical path to 1 million TPS via vertical scaling (specialized hardware for proof verification).
Modular
Client Design
1M+ TPS
Vertical Scale
STATELESS ETHEREUM CORE
Witness Size: The Make-or-Break Metric
Comparison of witness generation schemes for stateless clients, quantifying the data overhead required to prove state access.
| Metric / Feature | Verkle Tries (Current Path) | Binary Merkle Patricia Tries (Legacy) | STARK-based Proofs (Future Path) |
|---|---|---|---|
Witness Size per Transaction | ~0.2 - 1 KB | ~0.5 - 3 KB | < 0.1 KB (projected) |
Witness Nodes per Account Proof | 1 (Verkle Node) | 6-9 (MPT Nodes) | 1 (STARK Proof) |
Proof Composition | Vector Commitments (KZG) | Hash-based Merkle Proofs | Zero-Knowledge Proofs |
Bandwidth per Block (est.) | 1-2 MB | 8-16 MB | ~0.5 MB (projected) |
Client Verification Complexity | O(1) for KZG | O(log n) for hashes | O(1) with SNARK verifier |
Requires Trusted Setup | |||
Primary Research/Dev Entity | Ethereum Foundation | Pre-merge Ethereum | StarkWare, Polygon zkEVM |
Compatible with Current EVM |
deep-dive
THE VERIFICATION PAYLOAD
Deep Dive: Anatomy of a State Witness
A state witness is a cryptographic proof that a specific piece of data exists within the global Ethereum state, enabling stateless verification.
A witness is a Merkle proof. It contains the minimal set of Merkle-Patricia Trie hashes needed to prove a leaf node's inclusion in the state root. This allows a client to verify a transaction without storing the entire state.
Witness size is the core bottleneck. A simple ETH transfer requires a ~3KB witness, but a complex Uniswap swap interacting with multiple contracts can balloon to over 100KB. This makes bandwidth, not computation, the primary constraint for stateless clients.
Verkle Tries are the designed solution. They replace Merkle-Patricia Tries to compress witness sizes by ~20-30x using vector commitments. This is the key upgrade in Ethereum's stateless roadmap to make witness propagation viable.
Evidence: The current Ethereum state is ~250GB. A stateless client using Verkle proofs would only need the block headers and a constant-sized witness for each transaction, fundamentally altering node hardware requirements.
FREQUENTLY ASKED QUESTIONS
FAQ: The Practical Implications of Statelessness
Common questions about relying on State Witnesses: The Core of Stateless Ethereum.
A state witness is a cryptographic proof that a specific piece of data exists in Ethereum's global state. It allows a node to verify a transaction without storing the entire state, using Merkle proofs or Verkle trees to prove account balances or contract storage.
future-outlook
THE DATA LAYER
Future Outlook: Witnesses Beyond The Verge
State witnesses will become a foundational data primitive, enabling stateless verification across the modular stack.
Witnesses are a data primitive. The Verkle tree proof is the first standardized witness format, but the concept generalizes to any succinct proof of arbitrary state. This creates a universal language for trust-minimized data transport.
Modular execution depends on witnesses. Layer 2s like Arbitrum and Optimism currently post full state diffs to Ethereum. Post-Verge, they will post compact witnesses, slashing L1 data costs by over 90% and enabling cheaper fraud/validity proofs.
Cross-chain intents require verified state. Protocols like UniswapX and CowSwap settle intents across chains. A witness proving asset ownership on Chain A becomes the atomic input for a swap execution on Chain B, bypassing traditional bridge latency.
Evidence: The scaling math is definitive. A Verkle witness for a complex Uniswap V3 swap is ~200 bytes. The same data as a current Merkle-Patricia proof is ~3KB. This 15x compression is the minimum viable efficiency for global-scale stateless clients.
takeaways
STATE WITNESSES
Takeaways for CTOs and Architects
Statelessness is the endgame for Ethereum scalability. Here's what you need to build for it.
01
The Problem: Your Node is a Data Hoarder
Full nodes store the entire state (~1TB+), creating massive sync times and hardware requirements. This centralizes validation and bottlenecks Layer 2 finality.
- Sync time for a new node: Days to weeks.
- Minimum hardware cost: ~$1k+ for fast SSD storage.
- Consequence: Fewer validators, weaker decentralization.
1TB+
State Size
~$1k
Min Hardware Cost
02
The Solution: Verkle Trees + State Witnesses
Replace Merkle Patricia Tries with Verkle Trees to shrink proof sizes from ~1MB to ~150 bytes. A 'state witness' is this tiny proof a block proposer provides to prove state changes.
- Enables stateless clients that require near-zero storage.
- Allows instant syncing from a genesis block.
- Foundation for PeerDAS and exponential blob scalability.
~150B
Witness Size
Instant
Sync Time
03
Architect for Stateless Execution Now
Your protocol's state access patterns will determine its survival. Start instrumenting your contracts and clients.
- Audit storage patterns: Minimize scattered SLOADs; batch operations.
- Plan for witness propagation: Your RPC/sequencer must handle ~1-10KB of witness data per block.
- Benchmark against prototypes: Test with Reth or Erigon stateless forks.
1-10KB
Witness/Block
Critical
SLOAD Cost
04
The New Security Model: Witness Reliability
Validity shifts from storing state to verifying witnesses. The network must ensure honest proposers can propagate witnesses faster than attackers.
- New attack vector: Witness withholding or DoS.
- Solution: PeerDAS sampling and builder-level guarantees.
- Implication: L2 security will depend on L1's witness availability.
New Vector
Witness DoS
PeerDAS
Core Mitigation
05
Bandwidth is the New Bottleneck
With tiny proofs, the constraint moves from disk I/O to network I/O. Every node becomes a light client, constantly streaming witnesses.
- Requirement: ~100 Mbps+ stable connections.
- Comparison: Far less than streaming full blocks, but more sensitive to latency.
- Impact: Geographic distribution of nodes becomes even more critical.
~100 Mbps
Node Bandwidth
Latency
Key Metric
06
The L2 Finality Accelerator
Statelessness is the key to single-slot finality. When validators don't need to sync state, they can finalize blocks in ~12 seconds.
- Direct benefit: L2s (Arbitrum, Optimism, zkSync) achieve near-instant hard finality.
- Eliminates the soft-confirmation risk window.
- Unlocks cross-rollup interoperability at L1 speed.
~12s
Finality Time
Hard Finality
For L2s
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