Statelessness eliminates state bloat. Every full node today must store the entire chain history, creating an unsustainable hardware burden that centralizes network participation. This model is a direct barrier to scaling.
wallet-wars-smart-accounts-vs-embedded-wallets
Blog
Why Statelessness Is the Ultimate Goal for Scalable Sessions
Smart accounts and session keys are just the first step. True mass adoption requires a stateless architecture that eliminates on-chain storage overhead. This is the technical endgame for the Wallet Wars.
introduction
THE SCALABILITY IMPERATIVE
Introduction
Statelessness is the only viable path to scaling blockchain sessions to global transaction volumes without compromising decentralization.
The session layer is the bottleneck. Protocols like Uniswap and Aave generate immense ephemeral data (e.g., pending intents, partial signatures) that current state models must permanently record. This is wasteful and slow.
Stateless clients verify, they don't store. Inspired by Verkle trees in Ethereum's roadmap, nodes validate blocks using cryptographic proofs instead of holding full state. This reduces the hardware requirement from terabytes to gigabytes.
Evidence: Ethereum's state size exceeds 1TB, growing ~50GB/year. A stateless client, in contrast, needs only a ~1MB witness to verify any transaction, enabling mobile-scale participation.
key-trends
WHY STATELESSNESS IS THE ULTIMATE GOAL
The Scalability Trilemma of Modern Sessions
Current session key systems are trapped by the trade-offs between security, scalability, and decentralization. Statelessness is the only architecture that breaks this deadlock.
01
The Problem: State Bloat Cripples Scaling
Every active session requires validators to store and sync its state, creating an O(n) scaling problem. This leads to:\n- Exponential hardware costs for node operators.\n- Network-wide latency spikes during peak usage, as seen in early Ethereum DeFi summers.\n- A hard cap on concurrent users, limiting dApp growth to ~hundreds of thousands of sessions.
O(n)
Scaling
100k
Session Cap
02
The Solution: Stateless Verification with SNARKs
Move state validation off-chain. Clients provide a cryptographic proof (e.g., a zk-SNARK) that their action is valid against a known state root. This enables:\n- Constant-time verification for validators, regardless of session complexity.\n- Sub-second finality for user actions, enabling real-time applications.\n- Massive parallelism, as seen in Starknet and zkSync architectures.
~500ms
Finality
1k+ TPS
Per Session
03
The Enabler: Intent-Based Abstraction
Statelessness requires rethinking user interaction. Instead of managing granular state transitions, users sign high-level intents. Protocols like UniswapX and CowSwap resolve these intents off-chain, submitting only the final, proven settlement. This delivers:\n- Gasless user experiences with sponsored transactions.\n- Optimal execution via solver networks.\n- Atomic composability across chains via intents, a core innovation of Across and LayerZero.
$0
User Gas
10x
Efficiency
04
The Trade-off: Data Availability is the New Bottleneck
Stateless clients need guaranteed access to state data to construct proofs. This shifts the scaling challenge to Data Availability (DA). The market is fracturing between:\n- Ethereum using EIP-4844 blobs for ~$0.01 per session.\n- Celestia and EigenDA offering dedicated DA layers at ~$0.001 per session.\n- Validiums making a security-for-cost trade-off, used by Immutable X.
~$0.001
DA Cost
100x
Cheaper
05
The Architecture: Session Keys as Light Clients
In a stateless future, a session is not a server-side object but a permission bundle verified by a light client. This mirrors Bitcoin's SPV model. The user's device holds the minimal state (merkle proofs), enabling:\n- Truly decentralized sessions with no trusted intermediaries.\n- Instant migration between devices and wallets.\n- Native multi-chain sessions, as the verification logic is chain-agnostic.
0 KB
Node State
Instant
Recovery
06
The Outcome: Unbundling Security and Execution
Final card. Statelessness completes the modular blockchain thesis. Security is provided by a base settlement layer (e.g., Ethereum), execution is handled by stateless rollups, and sessions become portable assets. This creates:\n- Specialized L2s for gaming or social with ~1M+ concurrent users.\n- Capital efficiency, as security isn't re-paid for each session.\n- A winner-takes-most market for execution environments, not monolithic chains.
1M+
Concurrent Users
-90%
Overhead
thesis-statement
THE SCALABILITY BOTTLENECK
Thesis: Sessions Are State, and State Is the Enemy
Session-based UX requires persistent, verifiable user state, which directly contradicts the stateless scaling paradigm of blockchains like Ethereum.
Sessions create persistent state. A session wallet, like those from Privy or Dynamic, maintains a temporary key and a bundle of pending user intents. This session object must be tracked and validated across multiple blocks, creating a new class of on-chain state that is expensive to store and synchronize.
State is the scaling bottleneck. Ethereum's roadmap, via Verkle trees and stateless clients, aims to eliminate the need for nodes to store full state. Sessions reintroduce this burden at the application layer, forcing sequencers and validators to manage ephemeral but critical data, mirroring the problems of early rollup state growth.
Stateless verification is the goal. The endgame is a session proof—a ZK proof of valid state transitions—that a verifier can check without knowing the session's internal data. Projects like Cartesi and RISC Zero are exploring this for general compute, but applying it to mutable session state remains unsolved.
Evidence: The gas cost for storing 1KB of session data on Ethereum Mainnet is ~640,000 gas. For a service processing 10,000 concurrent sessions, this represents a constant overhead of over 6.4 billion gas, or approximately $200,000 at 50 gwei, just for state allocation, not computation.
SESSION KEY ARCHITECTURES
The Storage Cost of Convenience
Comparing the state storage burden and security trade-offs of different session key models for scalable user experiences.
| Core Metric | Traditional Signer (EOA) | Stateful Session Keys | Stateless Session Keys (Ideal) |
|---|---|---|---|
State Growth per User | 0 bytes (External) | ~1-5 KB per active session | 0 bytes |
Node Storage Overhead | None | Linear with active users | Constant (O(1)) |
Revocation Latency | Immediate | 1 block (on-chain txn) | Immediate (cryptographic proof) |
Trust Assumption | None (User custody) | Validator/Sequencer honesty | Cryptographic (ZK/MPC) |
Scalability Bottleneck | UX (signing pop-ups) | On-chain state bloat | Prover compute/bandwidth |
Implementation Example | MetaMask | ERC-4337 Session Keys, dYdX v3 | ZK Email, Sui zkLogin, Privy's ZK Sessions |
Gas Cost per Session Op | ~21k gas (base txn) | ~45k+ gas (state update) | < 5k gas (proof verification) |
Supports Parallel Sessions |
deep-dive
THE STATE CRISIS
Architecting the Stateless Future: ZK Proofs and Verifiable Off-Chain State
Statelessness, enabled by ZK proofs, is the only viable path to scaling blockchains without compromising decentralization.
State growth is the existential bottleneck. Every full node must store the entire chain state, creating a hardware arms race that centralizes validation. Stateless clients solve this by only requiring a small cryptographic commitment, like a Merkle root, to verify transactions.
ZK proofs are the verification engine. A zk-SNARK proves a state transition is correct without revealing the underlying data. This allows light clients to trustlessly verify blocks, a concept pioneered by Mina Protocol's 22kb blockchain.
Verifiable off-chain execution is the scaling vector. Systems like zkSync and StarkNet compute transactions off-chain and submit a single validity proof. This decouples execution from consensus, enabling massive throughput without bloating L1 state.
The endgame is universal state expiry. Ethereum's Verkle Trees and EIP-4444 are foundational steps. Nodes will prune old state, relying on users or specialized services to provide proofs for historical data, radically reducing sync times and hardware requirements.
protocol-spotlight
THE STATELESS FUTURE
Builders on the Frontier
Statelessness is the endgame for scaling blockchains, shifting the state burden from nodes to users to achieve global-scale throughput.
01
The Problem: The State Explosion
Full nodes must store and process the entire chain state, creating a ~1 TB+ storage burden and limiting throughput to ~10-100 TPS. This is the fundamental bottleneck for mass adoption.
- Resource Centralization: High hardware costs push validation to a few entities.
- Sync Time Bloat: New nodes take days to sync, harming liveness and decentralization.
1 TB+
State Size
<100
Max TPS
02
The Solution: Stateless Clients & Witnesses
Clients only verify block headers and cryptographic proofs (witnesses) for relevant state, eliminating the need for local state storage. This is the core innovation behind Ethereum's Verkle Trees and projects like Mina Protocol.
- Constant Node Cost: Validation overhead becomes independent of total state size.
- Instant Sync: New nodes can join the network in seconds, not days.
~500ms
Sync Time
10K+
Theoretical TPS
03
The Bridge: State Providers & PBS
A new market emerges for specialized state providers (e.g., EigenLayer AVSs, Ulvetanna) that serve witnesses. This aligns with Proposer-Builder Separation (PBS), creating a scalable, decentralized supply chain for state data.
- Economic Efficiency: Builders pay for state access, users pay for verification.
- Specialization: Hardware-optimized providers enable ultra-low latency witness generation.
New Market
State Providers
~100ms
Witness Latency
04
The Application: Stateless Rollups & Light Clients
Execution layers like Fuel Network and RISC Zero are pioneering stateless architectures from day one. This enables trust-minimized light clients to securely interact with any chain, a prerequisite for a multi-chain future.
- Horizontal Scaling: Each rollup can scale independently without congesting L1.
- Universal Access: Mobile devices become first-class participants in the network.
Fuel, RISC Zero
Pioneers
Mobile-First
Client Model
05
The Trade-off: Bandwidth vs. Computation
Statelessness exchanges storage for bandwidth. Witness sizes must be minimized (Verkle Trees reduce them from MBs to KBs) to prevent network congestion. This is the critical engineering challenge.
- Witness Compression: Advances in vector commitments and polynomial IOPs are key.
- Data Availability: Relies on robust layers like Ethereum Danksharding or Celestia.
MBs -> KBs
Witness Size
DA-Layer
Critical Dep
06
The Ultimate Goal: The World Computer
Final form: a network where any device can verify any transaction in real-time. This dissolves the full-node/light-client dichotomy, enabling truly decentralized applications with global-scale user bases and sub-cent transaction costs.
- Permissionless Verification: Security is accessible, not outsourced.
- Endgame Scalability: Removes the last major technical barrier to blockchain mass adoption.
Global Scale
User Base
<$0.01
Target Cost
counter-argument
THE STATE BOTTLENECK
Counterpoint: Is This Over-Engineering?
Statelessness is the only viable path to scaling session keys beyond niche use cases.
State growth is the enemy. Every active session key bloats the on-chain state, increasing node hardware requirements and centralizing the network. This directly contradicts the scalability promise of account abstraction.
Statelessness is the endgame. Protocols like Ethereum's Verkle Trees and zkSync's Boojum aim to decouple execution from state storage. Validators verify proofs without holding full state, enabling millions of concurrent sessions.
Current sessions are a bridge. Today's implementations, like Starknet's account contracts or Safe{Core}, are training wheels. They build user habit and developer tooling for the stateless future, where sessions become a native primitive.
Evidence: Ethereum's stateless roadmap targets a 90% reduction in witness sizes. Without this, session key adoption would make running an Ethereum node prohibitively expensive, recreating the web2 server-client model.
takeaways
THE STATE CRISIS
TL;DR for Busy Architects
Blockchain state growth is the existential bottleneck for scaling; statelessness is the only viable endgame.
01
The Problem: State Bloat Kills Node Decentralization
Full nodes today must store the entire chain history, leading to terabytes of data and prohibitive sync times. This centralizes validation to a few large operators, breaking the security model.
- Result: Ethereum state is ~1TB+ and growing.
- Consequence: Solo staking becomes a data center operation.
1TB+
State Size
Days
Sync Time
02
The Solution: Verkle Trees & Stateless Clients
Replace Merkle Patricia Tries with Verkle Trees (EIP-6800) to enable stateless validation. Clients verify blocks using tiny cryptographic proofs instead of holding full state.
- Key Benefit: Proof size drops from ~300 kB to ~150 bytes.
- Key Benefit: Enables light clients with full security guarantees.
~150B
Witness Size
>99%
Bandwidth Saved
03
The Enabler: SNARK/STARK Proofs for State Transitions
Layer 2s like zkSync and Starknet already use validity proofs for execution. The next step is applying them to state access, creating a stateless rollup.
- Mechanism: Prover attests to correct state root transition.
- Ultimate Goal: A node only needs the latest state root and a proof to validate the entire chain history.
zkEVM
Execution Prover
Single Root
Required Data
04
The Paradigm Shift: Separating Data from Validation
Statelessness inverts the blockchain model. Validation is no longer bound by local storage, enabling horizontal scaling of validators. This is the core innovation behind Ethereum's Purge phase and projects like Celestia (data availability) and Near's Nightshade.
- Result: Node requirements drop to consumer hardware.
- Consequence: True global decentralization becomes feasible.
Consumer HW
Node Specs
Horizontal
Scalability
05
The Immediate Win: Unlocking Light Client Supremacy
Stateless clients are essentially super-powered light clients. This enables trust-minimized bridges (like Succinct), secure mobile wallets, and instant sync for new chains.
- Use Case: A phone wallet that verifies its own transactions.
- Impact: Cuts reliance on centralized RPC providers like Infura.
~500ms
Verification
Zero Trust
Assumption
06
The Trade-off: Prover Centralization & Complexity
The catch: someone must generate the proofs. This creates a prover market risk and adds protocol complexity. Solutions like Proof of Useful Work (PoUW) and decentralized prover networks (Espresso Systems, Risc Zero) are emerging to address this.
- Risk: Proof generation becomes a centralized service.
- Mitigation: Incentivized, permissionless prover networks.
New Market
Prover Econ
High
Complexity Cost
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