Stateless sessions eliminate state bloat. Every player action in a traditional on-chain game writes permanent state, creating unsustainable storage costs and slow transaction finality on networks like Ethereum.
wallet-wars-smart-accounts-vs-embedded-wallets
Blog
Why Stateless Sessions Are the Future of On-Chain Gaming
The current model of on-chain gaming is broken. Stateless sessions—verifying off-chain state with on-chain settlement—are the only architecture that scales for high-frequency interactions. This is the core battleground in the Wallet Wars.
introduction
THE STATE PROBLEM
Introduction
On-chain games are hitting a fundamental scalability wall due to the cost and latency of state management.
The future is ephemeral execution. This model separates volatile session logic from persistent on-chain settlement, mirroring the architecture of rollups like Arbitrum and intent-based systems like UniswapX.
Evidence: A single complex game transaction can consume over 1 million gas on Ethereum Mainnet, while a stateless proof of the same action verifies for under 50k gas on a zk-rollup.
thesis-statement
THE STATE CRISIS
The Core Argument
On-chain gaming's current architecture is fundamentally broken due to state bloat, and stateless sessions are the only viable scaling path.
State bloat is terminal. Every in-game action today writes permanent state to the L1 or L2 ledger, creating unsustainable storage costs and latency that kills game design. This model guarantees eventual failure for any popular game.
Stateless sessions externalize computation. Games like Dark Forest and Primodium prove the model: core game logic runs off-chain in a verifiable environment (e.g., a zkVM), with only compressed proofs and final settlements posted on-chain. The chain becomes a finality layer, not a compute layer.
This enables new game mechanics. With state growth decoupled from chain cost, developers implement real-time strategy, complex physics, and massive persistent worlds previously impossible. The comparison is EVM's global state versus session-based local state.
Evidence: The Starknet-based Realms: Eternum handles thousands of concurrent players in a persistent world by using Cairo for off-chain game ticks and periodic state updates, demonstrating orders-of-magnitude higher complexity per gas unit.
key-trends
WHY STATELESS SESSIONS ARE INEVITABLE
The Three Trends Forcing This Shift
On-chain gaming's current infrastructure is buckling under the weight of its own ambition. Here are the three market forces making stateless sessions a non-negotiable evolution.
01
The Gas Fee Death Spiral
Every in-game action requiring a transaction is a UX and economic failure. Games like Parallel and Pirate Nation face player churn when simple moves cost $5+.
- Cost Prohibitive: Mass adoption requires sub-cent transaction costs.
- Latency Kills Immersion: ~12-second block times on Ethereum L1 destroy real-time gameplay.
- Economic Model Collapse: Microtransactions and free-to-play models are impossible.
$5+
Per Action Cost
12s
Base Latency
02
The Wallet Friction Bottleneck
Seed phrases and transaction pop-ups are the antithesis of seamless gaming. The ~90% drop-off between download and first action is catastrophic.
- Onboarding Wall: Traditional wallets like MetaMask are built for DeFi degens, not gamers.
- Session Security: Players shouldn't sign a TX for every loot drop.
- Abstraction Mandate: The winner will abstract wallets entirely, like Privy or Dynamic, but for gameplay.
90%
Onboard Drop-off
1-Click
Target UX
03
The Scalability Ceiling of State
Fully synchronized global state, as seen in MUD and Dojo, hits a hard limit. Storing every player's position and inventory on-chain doesn't scale to millions.
- State Bloat: A million concurrent players would require petabytes of chain history.
- Compute Offload: Real-time physics and AI must run off-chain, with only critical outcomes settled.
- Hybrid Architecture: The future is stateless session proofs (like Cartridge or Lattice) verifying off-chain execution.
1M+
Concurrent Players
PB
State Bloat
deep-dive
THE ABSTRACTED STATE
The Anatomy of a Stateless Session
Stateless sessions decouple game logic from on-chain state, enabling high-frequency interactions without L1 bottlenecks.
Stateless sessions are client-side proofs. The player's client locally computes game state changes, generating a validity proof (e.g., a zkSNARK) for the final outcome. This client-side execution shifts computational burden off-chain, making high-frequency actions like per-frame moves economically viable.
The chain becomes a verifier, not a computer. Protocols like Cartesi and Lumio demonstrate this model. The L1 or L2 only verifies the cryptographic proof of a correct session outcome, settling the result in a single transaction instead of thousands.
This inverts the gas economics of on-chain games. Traditional models like Dark Forest pay gas for every state update. Stateless sessions bundle an entire match into one proof, reducing costs by orders of magnitude and enabling complex game logic previously impossible on-chain.
Evidence: A Cartesi DApp chess game executes ~5 million logic steps off-chain, settling with one on-chain proof, demonstrating the TPS amplification possible when state management is abstracted away from settlement.
ON-CHAIN GAMING INFRASTRUCTURE
Architectural Showdown: Embedded vs. Smart vs. Stateless
A first-principles comparison of dominant architectures for managing player state, from traditional models to the frontier of stateless sessions.
| Core Feature / Metric | Embedded State (Traditional) | Smart Account State (ERC-4337) | Stateless Sessions (ERC-7579) |
|---|---|---|---|
State Storage Location | On-chain contract storage | On-chain account storage | Off-chain, signed by player |
Gas Cost per Player Action | $0.50 - $5.00 (high) | $0.10 - $1.00 (moderate) | < $0.01 (micro-transactions) |
Latency per Action (L2) | 2-12 sec (block time) | 2-12 sec (block time) | < 1 sec (instant verification) |
Supports Session Keys | |||
Session Granularity & Scope | N/A | Per account, broad permissions | Per action, hyper-specific rules |
Client-Side Compute & Proofs | |||
Eliminates On-Chain State Bloat | |||
Native Composability with DeFi |
protocol-spotlight
STATELESS SESSIONS
Who's Building This Future?
The next wave of on-chain games requires a new infrastructure primitive. These are the teams and architectures making it real.
01
The Problem: The On-Chain User is a Ghost
Every action requires a wallet signature, breaking immersion and creating a ~2-5 second UX cliff. This is why mass adoption stalls.\n- Signing Fatigue: Players sign dozens of micro-transactions per minute.\n- Session Fragility: Connection drops or wallet pop-ups kill the game state.
~3s
Per-Action Lag
90%+
Drop-off Rate
02
The Solution: Doomberg's Stateless Session Keys
Delegated signing authority for a limited time and scope, inspired by ERC-4337 account abstraction. The wallet signs once to establish a session.\n- Gas Sponsorship: The game or a relayer pays for gas, abstracting cost.\n- Action Batching: Hundreds of in-game moves compressed into one on-chain proof.
10x
Faster UX
-99%
Signatures
03
The Architecture: MUD Engine & World Engine
Frameworks like MUD and Argus Labs' World Engine provide the state management layer that makes sessions viable. They treat the blockchain as a verifiable database.\n- Efficient State Proofs: Clients sync only the game state they need, not the whole chain.\n- Sovereign Rollup Integration: Sessions work natively with high-throughput L2s and app-chains.
~500ms
Latency
1M+
TPS Potential
04
The Economic Layer: Session Relayer Networks
Who pays the gas? Decentralized relayer networks (like Gelato, Biconomy) sponsor transactions, enabling true free-to-play. This mirrors ERC-4337 paymasters.\n- Session Monetization: Games can bake gas costs into item sales or subscriptions.\n- Trustless Verification: Relayers are slashed for submitting invalid session bundles.
$0
User Gas Cost
-50%
On-Chain Cost
05
The Security Model: Constrained Delegation
Stateless doesn't mean trustless. Sessions are cryptographically bounded by time, asset caps, and allowed contracts. This is the core innovation.\n- No Blank Checks: A session key can only interact with pre-approved game contracts.\n- Instant Revocation: Players can invalidate a session key with one on-chain transaction.
0
Known Hacks
<1hr
Max Session Time
06
The Endgame: Autonomous Worlds & On-Chain AI
This is the infrastructure for persistent digital realities that outlive any single game studio. Sessions enable player-driven economies and AI NPCs with wallets.\n- Persistent Agents: Autonomous characters can act on-chain via session keys.\n- Composable Legos: Games become interoperable state machines, not walled gardens.
24/7
Uptime
100%
On-Chain
counter-argument
THE ARCHITECTURAL IMPERATIVE
The Centralization Trap (And How to Avoid It)
Stateless sessions eliminate the need for centralized game servers, solving the fundamental scaling and cost problem of on-chain games.
Traditional on-chain games centralize. They run game logic on a server to batch and submit transactions, creating a single point of failure and control. This defeats the purpose of blockchain.
Stateless sessions are the alternative. The client computes the game state locally and submits a validity proof (like a zkSNARK) to the chain. The chain only verifies, never computes.
This inverts the cost model. Execution cost scales with players, not actions. A session proof for 1000 moves costs the same as one move, enabling massively parallel gameplay.
The proof is the architecture. Projects like Lattice's MUD engine and Argus Labs' World Engine are building on this model. They use EIP-4337 account abstraction to bundle session proofs into single user operations.
takeaways
WHY STATELESS SESSIONS ARE THE FUTURE OF ON-CHAIN GAMING
TL;DR for Builders and Investors
Stateless sessions decouple ephemeral game state from the blockchain, enabling high-frequency, low-cost interactions while preserving finality and composability.
01
The Problem: The State Bloat Tax
Storing every game tick on-chain is a $100M+ annual tax on the industry, making real-time games economically impossible.
- State growth cripples node performance and inflates storage costs.
- Latency from L1 finality (~12s) kills real-time gameplay.
- Gas fees per action create a pay-to-play barrier.
$100M+
Annual Tax
~12s
L1 Latency
02
The Solution: Off-Chain Execution, On-Chain Settlement
Move game logic to a high-performance game server, using the blockchain only for asset ownership and final settlement.
- Sub-second latency enables real-time combat and physics.
- Gas costs reduced by ~99%, paid only per session, not per action.
- Preserves composability; final state and assets (like ERC-1155 tokens) remain on-chain for DeFi and marketplaces.
~99%
Cost Reduced
<1s
Latency
03
The Architecture: Validity Proofs & Session Keys
Security is maintained via cryptographic commitments and user-authorized session keys, not trust.
- Session Keys grant temporary, scoped authority to a game server.
- State commitments are posted on-chain, enabling fraud proofs (like Optimism) or validity proofs (like StarkNet).
- Enables massively parallel execution without congesting the base layer.
ZK/OP
Proof Systems
Scoped
User Auth
04
The Business Model: Unlocking the $200B Gaming Market
Stateless sessions enable sustainable Web3 games that can compete with Unity and Unreal Engine titles.
- True digital ownership via on-chain assets creates new revenue streams.
- Interoperable assets drive network effects across games and NFT marketplaces.
- Scalable user onboarding by abstracting wallets and gas during gameplay.
$200B
TAM
New Rev Streams
Ownership
05
The Competitor: Fully On-Chain Autonomous Worlds
Projects like Dark Forest and MUD champion a different, purist vision where all state is on-chain.
- Pros: Maximum verifiability, permissionless modding, and eternal persistence.
- Cons: Inherently limits game complexity and real-time interaction due to cost and speed.
- Verdict: Stateless sessions are for mass-market games; autonomous worlds are for experimental crypto-native primitives.
MUD
Framework
Purist
Philosophy
06
The Infrastructure Play: Who Builds the Rails?
This isn't just a game design shift; it's a massive infrastructure opportunity akin to AWS for gaming.
- Specialized L2s/Rollups (like Immutable zkEVM) will provide optimized gaming stacks.
- Session key management becomes critical wallet infrastructure (see ERC-4337 account abstraction).
- Provers & verifiers for game state become a new DePIN-like market.
L2/Rollup
Stack
ERC-4337
Wallet Std
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