State is the bottleneck. Every full node must store the entire ledger's history and current state, which grows linearly with usage. This creates a hard scaling limit for decentralization, as hardware requirements become prohibitive.
layer-2-wars-arbitrum-optimism-base-and-beyond
Blog
Why Statelessness is the Ultimate Scaling Breakthrough
State growth is the silent killer of decentralization. Statelessness decouples validator requirements from network activity, enabling true horizontal scaling. This is the core battleground for L2s like Arbitrum, Optimism, and Base.
introduction
THE DATA
The State Bloat Trap
Statelessness solves blockchain's fundamental scaling bottleneck by eliminating the need for every node to store the entire state.
Statelessness decouples execution from verification. Clients only need a small cryptographic proof of state changes, not the state itself. This is enabled by Verkle trees or STARKs, which compress state data into a constant-size witness.
Ethereum's roadmap depends on it. The Verkle tree transition (EIP-6800) is the prerequisite for stateless clients and ultimately Verkle state expiry. This enables single-slot finality and removes the primary constraint on validator count.
Evidence: A stateless Ethereum client could verify the network with a ~1 MB witness instead of the current hundreds of GB state. This reduces the hardware requirement for a node from an enterprise SSD to a consumer laptop.
thesis-statement
THE STATE PROBLEM
The Core Argument: Decoupling is Everything
Statelessness eliminates the primary bottleneck in blockchain scaling by decoupling execution from state verification.
Statelessness is the scaling breakthrough because it removes the requirement for every node to store and update the entire global state. This decouples execution from verification, enabling parallel processing and exponential throughput gains.
The bottleneck is state growth. Current L1s like Ethereum and L2s like Arbitrum require full nodes to manage petabytes of data, which centralizes infrastructure and caps TPS. Stateless clients verify state with cryptographic proofs, not storage.
The paradigm shift is verification, not execution. Projects like Sui and Fuel use this principle for parallel execution, but statelessness extends it to light clients. A node verifies a block's correctness via a Merkle proof or a zk-SNARK, not by replaying transactions.
Evidence: Ethereum's stateless roadmap targets light clients that sync in seconds with a 1 MB witness, not 15 TB of history. This enables trust-minimized bridging for protocols like Uniswap and LayerZero without running a full node.
key-trends
WHY STATELESSNESS IS THE ULTIMATE SCALING BREAKTHROUGH
The L2 Scaling Bottleneck Matrix
Current L2s are hitting fundamental data availability and state growth limits; statelessness re-architects the base layer to eliminate these constraints.
01
The Problem: The State Bloat Death Spiral
Every transaction permanently grows the global state, forcing nodes to store terabytes of data. This creates a centralizing force, as only well-funded entities can run full nodes, undermining decentralization.
- State size grows ~50 GB/year on Ethereum L1.
- Node sync times can take days, a critical failure mode for network health.
- Gas costs are dominated by state read/write operations, not computation.
~50 GB/yr
State Growth
Days
Sync Time
02
The Solution: Verkle Trees & Witnesses
Replace Merkle Patricia Tries with Verkle Trees, enabling stateless clients. Nodes verify blocks using compact cryptographic proofs (witnesses) instead of storing the entire state.
- Witness size is ~1-2 KB vs. gigabytes of state.
- Enables light clients with full security, not just trust assumptions.
- Paves the way for single-slot finality by simplifying block validation.
~1-2 KB
Witness Size
Full Security
Light Clients
03
The Result: Unbounded L2 Throughput
With a stateless L1, rollup sequencers no longer compete for scarce L1 block space for state updates. Data availability moves to dedicated layers like EigenDA or Celestia, decoupling execution from state growth.
- L2 TPS limited only by DA layer bandwidth, potentially 100k+ TPS.
- L1 becomes a pure settlement & consensus layer, its capacity constraints lifted.
- Enables massively parallel execution environments like Monad and Fuel.
100k+
Potential TPS
Decoupled
Execution/DA
04
The Protocol: Ethereum's Stateless Roadmap
This isn't theory; it's Ethereum's core upgrade path. The Verge upgrade introduces Verkle Trees, enabling statelessness. This directly resolves the data availability bottleneck that currently caps rollup scaling.
- The Verge (Verkle Trees) is a key post-Danksharding milestone.
- Danksharding provides cheap blob space for rollup data, but statelessness is needed for verification.
- Full realization unlocks the endgame of scalable, decentralized L2s.
The Verge
Next Major Epoch
Endgame
Scaling Solved
THE STATELESSNESS IMPERATIVE
State Growth vs. Node Cost: The Inevitable Math
A comparison of node operational models under exponential state growth, quantifying the hardware and cost requirements for full participation.
| Core Metric / Capability | Traditional Full Node (Status Quo) | Verkle Tree Node (Ethereum Roadmap) | Full Stateless Client (Ideal Endgame) |
|---|---|---|---|
State Size (2024, GB) | ~1500 GB (Ethereum Archive) | ~1500 GB (Same state, new proof) | 0 GB (No local state) |
Minimum RAM Requirement | 32 GB+ (for sync & execution) | 16 GB (Smaller witness proofs) | < 4 GB (Witness verification only) |
Storage I/O Bottleneck | High (Random SSD access for state) | Medium (Proof fetching + validation) | None (Stateless validation) |
Sync Time (From Genesis) | ~2 weeks (CPU/IO bound) | ~1 week (Bandwidth bound) | < 1 day (Bandwidth bound) |
Hardware Cost / Year (Est.) | $1500+ (High-end NVMe, RAM) | $800 (Mid-tier consumer SSD) | $300 (Raspberry Pi + bandwidth) |
Supports Execution & Validation | |||
Requires Trusted Setup / Prover | |||
Theoretical Scaling Ceiling | ~10k TPS (Hardware wall) | ~100k TPS (Witness size wall) |
|
deep-dive
THE ARCHITECTURAL SHIFT
How Statelessness Works: Witnesses, Not Warehouses
Statelessness scales blockchains by eliminating the need for nodes to store the entire state, instead requiring only cryptographic proofs of state changes.
Statelessness inverts the data problem. Instead of every validator storing the full state (a warehouse), they only need a small witness—a Merkle proof—attesting to the specific accounts and balances a transaction touches. This reduces node hardware requirements by orders of magnitude.
The breakthrough is verifiability without possession. A node verifies a transaction's validity by checking its witness against a single, compact cryptographic commitment to the global state, like a Verkle Tree root. This separates execution from storage, enabling ultra-light clients.
This enables horizontal scaling. With stateless validation, network throughput is no longer bottlenecked by the storage and I/O of individual nodes. Projects like Celestia and Ethereum's Verge roadmap are building the foundational data availability and proof systems required for this shift.
Evidence: Ethereum's current state is ~1TB and grows ~100GB/year. A stateless client, in theory, needs only kilobytes per block to validate, enabling validation on mobile devices.
protocol-spotlight
THE ENDGAME FOR SCALING
The L2 Race to Statelessness
Statelessness eliminates the need for nodes to store the entire state, unlocking exponential scaling by shifting the burden of proof from storage to computation.
01
The Problem: State Bloat is a Ticking Bomb
Every L2 and L1 today requires nodes to store the entire global state, which grows linearly with usage. This creates unsustainable hardware requirements, centralization pressure, and slow sync times.
- Ethereum's state is ~1TB+ and growing
- Node sync times can take weeks
- Hardware costs create centralization risk
~1TB+
State Size
Weeks
Sync Time
02
The Solution: Stateless Clients & Verkle Trees
Nodes no longer store state; they verify execution using cryptographic proofs (like Verkle proofs) of the specific state they need. This reduces the node requirement from storing everything to verifying small proofs.
- Verkle Trees enable efficient (~150 byte) witness proofs
- Nodes become stateless, requiring only block headers
- Enables true lightweight client verification
~150B
Proof Size
>1000x
Node Scalability
03
The Race: zkSync's Boojum vs. Starknet's Stateless
L2s are competing to implement stateless verification first. zkSync uses the Boojum prover for recursive STARKs, aiming for ultra-cheap proving. Starknet is pioneering a stateless model where sequencers don't hold full state, relying on state diffs and proofs.
- Boojum targets sub-cent proving costs
- Starknet's path decouples state growth from node requirements
<$0.01
Target Proof Cost
~500ms
Verification
04
The Ultimate Prize: The Modular Stateless Stack
Statelessness enables a fully modular future. Execution, settlement, and data availability layers can specialize, connected by light clients verifying proofs. This is the foundation for Ethereum's Purge and projects like Celestia and EigenDA.
- Enables secure light client bridges (like IBC)
- Unlocks horizontal scaling across rollups
- Reduces L1 finality load to proof verification
10x+
Chain Capacity
-99%
L1 Burden
counter-argument
THE REALITY CHECK
The Skeptic's View: Complexity and Latency
Statelessness solves the data problem but introduces new bottlenecks in computation and coordination.
Statelessness trades storage for compute. The core innovation is shifting the burden from global state storage to local proof verification. This creates a verifier's dilemma where nodes must process complex SNARKs or STARKs for every transaction, not just simple signatures.
Latency is the new bottleneck. Finality depends on proof generation speed. Current zkEVM provers like those from Polygon zkEVM or zkSync Era add 10-20 minute delays, making them unsuitable for high-frequency DeFi or gaming applications that require sub-second confirmation.
Client complexity explodes. Light clients must become succinct verifiers, requiring constant upgrades for new proof systems and cryptographic assumptions. This centralizes client development to teams like EF's Portal Network or Helios, undermining decentralization.
Evidence: Today's most advanced stateless testnets, like Ethereum's Verkle-based devnets, show a 5-10x increase in block verification time versus current mainnet, highlighting the compute-for-storage tradeoff that defines the next scaling frontier.
takeaways
THE STATE CRISIS
TL;DR for Architects
Blockchain state growth is the fundamental bottleneck. Statelessness eliminates the need for full nodes to store it, unlocking scaling at the protocol layer.
01
The Problem: The State Bloat Tax
Every full node must store the entire global state (accounts, balances, smart contracts), which grows linearly with usage. This imposes a hard decentralization limit and makes syncing a node prohibitive.
- Cost: Running an Ethereum archive node requires ~12TB+ of storage.
- Consequence: Centralizes validation, creating systemic risk and limiting throughput.
12TB+
Archive State
Linear
Growth
02
The Solution: Verkle Trees & Witnesses
Replace Merkle Patricia Tries with Verkle Trees (vector commitments). This allows for tiny, constant-sized cryptographic proofs (witnesses) that a piece of state is valid, without needing the whole dataset.
- Key Benefit: Nodes verify blocks with ~1MB witnesses instead of storing terabytes.
- Key Benefit: Enables stateless clients and stateless validation, the prerequisite for true scaling solutions like Ethereum's Verge.
~1MB
Witness Size
Constant
Proof Size
03
The Architecture: Separating Execution from Validation
Statelessness refactors the node stack. Execution clients (like Geth) become stateless, requesting only the specific state they need via witnesses. Separate proving systems (e.g., zk-SNARKs) can aggregate and verify these proofs at scale.
- Result: Validators can run on resource-constrained devices, preserving decentralization.
- Synergy: This is the missing piece for zkEVM rollups and peer-to-peer networking to reach their full potential.
>10k TPS
Theoretical Cap
Mobile
Client Target
04
The Immediate Impact: Supercharged Rollups
Statelessness isn't just for L1. Rollups (Optimistic & ZK) are stateful systems facing the same growth problem. A stateless design allows sequencers to process transactions without local state, pulling data on-demand.
- Key Benefit: Drastically reduces sequencer hardware costs, increasing profit margins and decentralization.
- Key Benefit: Enables instant, trustless bridging between rollups via shared state proofs, solving fragmentation.
-90%
Sequencer Cost
Trustless
Interop
05
The New Abstraction: State Providers as a Service
If validators don't hold state, who does? A new market emerges for state providers (e.g., Portal Network, The Graph). They become specialized, incentivized services that store state and serve witnesses.
- Key Benefit: Creates a decentralized market for state availability, separate from consensus.
- Key Benefit: Enables pay-as-you-go state access, a more efficient economic model than full replication.
New Market
Economic Layer
Modular
Architecture
06
The Ultimate Goal: The Stateless Blockchain
The endgame is a chain where no participant needs the full state. Validation is done via cryptographic proofs, and execution is a stateless function. This dissolves the trilemma.
- Result: Horizontal scalability - throughput increases with the number of stateless validators.
- Legacy: Renders the 'blockchain scalability trilemma' obsolete, as pioneered by research into Polynomial Commitments and projects like Mina Protocol.
Trilemma Solved
Scalability
Horizontal
Scaling
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