Why Stateless Execution is the Missing Piece for Modular Blockchains

Full nodes must store and process the entire chain state, limiting throughput and decentralization. This is the core scaling wall for monolithic and modular rollups alike.

• State size grows ~1 TB/year for chains like Ethereum, creating prohibitive hardware requirements.
• Execution is serialized; every node re-runs every transaction, capping TPS.
• Rollups inherit this flaw, as their sequencers are just smaller, faster monoliths.

Separate the prover (which executes) from the verifier (which checks). Verifiers only need a cryptographic proof and a tiny state commitment, not the full state.

• Witnesses & Proofs: Transactions provide cryptographic 'witnesses' for the state they touch; validity proofs (ZK) or fraud proofs verify correctness.
• Constant-Time Verification: Node workload becomes O(1) relative to state size, enabling ~10,000 TPS on consumer hardware.
• Enables Light Client Finality: Clients can securely verify execution without syncing state, unlocking ~2-second finality for cross-chain apps.

Ethereum's core upgrade to enable stateless clients. Replaces Merkle Patricia Tries with Vector Commitment trees (Verkle Trees).

• Witness sizes shrink from ~1 MB to ~200 bytes, making them feasible to broadcast in blocks.
• Paves the way for full statelessness, where validators no longer store state, radically lowering node requirements.
• Critical enabler for PeerDAS and exponential data scaling, as execution nodes become stateless verifiers.

A monolithic L1 implementing stateless execution at the protocol level for real-time performance. Co-founded by Liu Jiang (ex-Citadel Securities).

• Single-Seat Sequencer processes transactions with parallel execution and continuous state commitment.
• Full nodes are stateless verifiers, receiving state diffs and proofs, targeting 100,000 TPS and ~200ms block times.
• Demonstrates the endgame: a blockchain that feels like a centralized database but is verifiably decentralized.

Applies stateless principles to the rollup stack. Provides a decentralized ZK-Prover network and a shared sequencer for instant-finality rollups.

• Decouples proof generation from sequencing, allowing rollups to be 'stateless' execution environments.
• Provers generate ZK proofs off-chain; the base layer only verifies, enabling ~3-second finality for sovereign chains.
• Shows the modular path: Base layer for consensus/data, 3rd-party prover network for execution, rollup for logic.

Stateless execution enables a new design pattern: the Sovereign Rollup with an Alternative Data Availability (AltDA) layer like Celestia or EigenDA.

• Rollup executes statelessly, posts data+proofs to AltDA, and inherits its security.
• Settlement is optional; verification is done by light clients using the DA layer's consensus.
• Ultimate modularity: Mix-and-match execution, data, consensus, and settlement. Fuel Network and Dymension RollApps are early examples.

Rollups and validiums must publish or attest to massive state diffs. This creates a quadratic scaling problem for Layer 1s and data availability layers like Celestia or EigenDA.\n- State growth outpaces hardware: Historical state for chains like Arbitrum or Optimism already exceeds 10+ TB.\n- Verifier Dilemma: Full nodes become prohibitively expensive, pushing validation to a handful of professional operators.

Stateless clients require cryptographic witnesses (Merkle proofs) for every transaction. Transmitting these proofs creates immense bandwidth overhead, negating the scalability gains of modular design.\n- Bandwidth Bloat: Witness size can be ~1-10 KB per transaction, multiplying base layer congestion.\n- Latency Penalty: Proof aggregation and propagation add ~100-500ms of latency, breaking the UX for fast L2s like Solana or high-frequency dApps.

The computational and data burden of stateful verification inevitably consolidates power. Projects like Polygon zkEVM or zkSync face a trilemma: scale, decentralize, or keep costs low—pick two.\n- Prover Monopolies: ZK-proof generation becomes a specialized, capital-intensive service, akin to mining pools.\n- Settlement Layer Risk: Ethereum L1 becomes a bottleneck, forcing modular chains to either fragment security or accept high fees.

The bear case concludes that without a shift to stateless execution—where nodes verify without holding state—modular stacks will hit a hard ceiling. This is the core innovation behind Ethereum's Verkle Trees and projects like Fuel v2 and RISC Zero.\n- Constant Node Cost: Verification resource requirements become independent of total state size.\n- True Horizontal Scaling: Enables thousands of parallel execution layers without collapsing the base layer, unlocking the original modular vision.

Rollups like Arbitrum and Optimism require full nodes to store the entire state, creating a ~100GB+ operational burden that centralizes nodes and limits throughput. The state size grows linearly with usage, making sync times and hardware requirements unsustainable.

• Bottleneck: State growth is the primary constraint on validator decentralization.
• Consequence: High hardware costs lead to centralized sequencer/prover sets.
• Impact: Limits theoretical TPS as every node must process everything.

Stateless clients (e.g., Ethereum's Verkle Trees) only need a cryptographic proof (witness) of relevant state, not the full database. Execution layers like Risc Zero and Succinct Labs enable this via validity proofs for arbitrary computation.

• Mechanism: Provers generate ZK proofs or validity proofs that state transitions are correct.
• Result: Node requirements drop from terabytes to megabytes of data.
• Enables: Light clients that can verify execution with ~1MB witnesses.

Projects like Celestia and EigenDA provide cheap data availability; stateless execution provides cheap verification. This creates a clean separation: DA layers store data, execution layers prove correctness, and settlement layers enforce consensus.

• Stack: Celestia (DA) + Risc Zero (Execution) + Ethereum (Settlement).
• Benefit: Enables sovereign rollups that are not bound to a specific settlement layer's execution rules.
• Future: Unlocks parallel execution environments where proofs are the universal language.

The computational burden shifts from validators to provers, creating a new centralization vector. Generating ZK proofs is computationally intensive (~1-10 seconds for simple tx). Networks must efficiently gossip witnesses (state proofs) without creating new bandwidth bottlenecks.

• Risk: Proof generation becomes a specialized, centralized service.
• Challenge: Witness size must remain small (<1-2KB) for efficient p2p propagation.
• Mitigation: Recursive proof aggregation (e.g., Nova) and dedicated prover markets.

Monolithic chains like Solana and parallel EVMs like Monad attack the same throughput problem differently. They keep stateful execution but optimize hardware utilization and parallelize transaction processing. This is a fundamental architectural fork.

• Solana's Approach: Sealevel parallel runtime + Cloudbreak state architecture.
• Monad's Approach: Parallel EVM with asynchronous execution and optimistic state access.
• Verdict: Stateless excels in modular, trust-minimized designs; stateful parallelization excels in raw performance for unified environments.

Stateless execution is the final piece for a truly modular stack. It allows execution environments to be commoditized, as their security is defined by cryptographic proofs, not social consensus on state. This enables:

• Interoperability: Chains become state machines defined by a proof verifier.
• Developer Freedom: Launch a chain with custom VM without bootstrapping a validator set.
• User Sovereignty: Light clients can securely verify any chain from a phone. The future is multi-chain, secured by cryptography, not capital.