Identity data is heavy. A single on-chain soulbound token (SBT) profile from Ethereum Attestation Service or World ID contains more data than a simple ERC-20 transfer. Scaling to billions of users requires a new data paradigm.
The Scalability Crisis of Global On-Chain Identity Systems
Storing and verifying credentials for Network States and tokenized citizenship will create a data avalanche that current L1/L2 architectures cannot handle. This analysis breaks down the coming bottleneck and the essential shift towards modular data availability and decentralized indexing.
The Coming Data Avalanche
Global on-chain identity systems will generate more data than current L1s can process, creating a new bottleneck.
L1s are not databases. Ethereum and Solana optimize for financial settlement, not for querying complex social graphs. Storing identity proofs on-chain is a misuse of consensus that will congest networks and inflate costs.
The solution is modular. Identity systems must separate the attestation layer (on-chain, for security) from the data availability layer (off-chain, for scale). This mirrors the rollup-centric roadmap where Celestia or EigenDA handle data, not execution.
Evidence: A single zk-proof for a World ID verification is ~45KB. At 1 million daily verifications, that's 45GB of data—more than Ethereum's entire historical state growth in a week.
The Three Inevitable Bottlenecks
Global on-chain identity systems promise a unified web3 passport, but face fundamental scaling limits that threaten their viability.
The Problem: The State Bloat Catastrophe
Storing identity credentials directly on-chain for billions of users creates unsustainable ledger bloat. Every new user adds permanent, immutable data that every node must replicate forever, leading to exponential state growth and crippling sync times for new validators.\n- Cost: ~$1-5 per credential write on Ethereum L1\n- Impact: Makes running a full node prohibitive, centralizing the network\n- Example: ENS names are a lightweight preview; full social graphs would be impossible.
The Problem: The Privacy vs. Verification Paradox
Proving unique humanity or credentials without exposing personal data requires zero-knowledge proofs (ZKPs). Generating these proofs is computationally intensive, creating a latency and cost bottleneck for mass adoption.\n- Latency: ZK proof generation can take ~2-10 seconds per user action\n- Cost: ~$0.10-$0.50 in compute fees per proof on a rollup\n- Trade-off: Faster, cheaper proofs often compromise on security or decentralization (e.g., trusted setups).
The Solution: Off-Chain Attestations, On-Chain Verification
The viable architecture shifts the heavy storage and compute off-chain. Systems like Ethereum Attestation Service (EAS) and Verax store only tiny, verifiable fingerprints (hashes) on-chain. The actual credential data lives in decentralized storage (IPFS, Arweave) or private servers.\n- Efficiency: On-chain footprint reduced by >99%\n- Flexibility: Supports any data schema and issuer\n- Composability: Hashes can be referenced across dApps (DeFi, DAOs, Social).
The Solution: Layer 2 & App-Specific Identity Rollups
Identity verification is moved to high-throughput execution layers. Optimism's AttestationStation and custom zkRollups for identity (like zkEmail's circuit) batch thousands of proofs, amortizing cost and latency. This creates identity-specific scaling lanes.\n- Throughput: ~10,000+ verifications per second on a rollup\n- Cost: Batch verification reduces per-proof cost to <$0.001\n- Example: Worldcoin's Orb verification runs off-chain, with periodic state updates to a rollup.
The Solution: Intent-Based & Delegated Verification
Instead of verifying every user for every action, systems verify intent fulfillment. Protocols like UniswapX and CowSwap use solvers; identity systems can use delegated attestation networks. Users prove identity once to a trusted relayer network (e.g., Witness Chain), which issues session credentials.\n- User Experience: Zero-gas, instant subsequent interactions\n- Architecture: Shifts verification load to a specialized, competitive network\n- Analogy: Like TLS certificates for web2, issued once then cached and trusted.
The Inevitable Trade-Off: Decentralization vs. Scale
Global scale requires accepting gradients of decentralization. The base layer (e.g., Ethereum L1) provides ultimate security for root keys and consensus. Execution and data availability shift to L2s and DA layers (Celestia, EigenDA). Credential issuance may involve trusted oracles (Chainlink) for real-world data.\n- Reality: Fully decentralized, global, private, and cheap is impossible—pick three.\n- Design: Optimize for sufficient decentralization at each layer of the stack.\n- Future: Aggregation layers (like EigenLayer AVS) will host identity verification as a service.
Why Monolithic Chains and Simple Rollups Will Fail
Global on-chain identity requires a data and compute scale that monolithic architectures cannot physically achieve.
Monolithic chains centralize state. A single global state machine must process every identity verification, proof, and revocation. This creates an unscalable bottleneck where throughput is limited by the slowest node's hardware, not the network's aggregate capacity.
Simple rollups inherit the data problem. While they offload execution, they still post all identity state transitions to a base layer like Ethereum. The resulting data availability costs make frequent, granular identity updates economically impossible for billions of users.
Sovereign identity demands parallel execution. Identity verification for a DeFi user in Singapore is independent of a gaming avatar mint in Brazil. A monolithic sequencer processes these serially, while a modular stack with dedicated identity rollups processes them in parallel.
Evidence: Ethereum processes ~15 transactions per second. A global identity system for 1B users making one weekly action requires ~1,600 TPS just for identity ops. This is why projects like Worldcoin and Polygon ID architect around specialized, scalable proving networks.
Data Load Projections: The Billion-User Reality
Comparing the data load and infrastructure demands of leading on-chain identity paradigms at 1B+ users.
| Metric / Capability | Soulbound Tokens (SBTs) | Decentralized Identifiers (DIDs) | Attestation Networks (e.g., EAS) |
|---|---|---|---|
On-Chain Storage per User | 1-5 KB (persistent) | ~100 bytes (registry pointer) | ~200 bytes (attestation hash) |
Annual State Growth (1B users) | 1-5 TB | ~100 GB | ~200 GB |
Primary Write Load | Minting & Burning | Create/Update DID Document | Issue/Revoke Attestation |
Read-Optimized Architecture | |||
Supports Off-Chain Data (IPFS, Ceramic) | |||
Gas Cost per Identity Action | $10-50 (L1) | $2-5 (L2) | $0.50-2 (L2) |
Requires Global Consensus for Updates | |||
Annual L1 Calldata Cost (1B updates) | $1.5B+ | $300M | $75M |
The Infrastructure Pivot: DA Layers & Indexers
Universal on-chain identity systems like ENS, Lens, and Farcaster are hitting the same wall: monolithic L1s cannot index and serve global social graphs.
The Problem: The ENS Bottleneck
ENS's ~3 million names are stored on Ethereum L1, making reads/writes prohibitively expensive and slow for mass adoption. Indexing this data for a global app requires centralized services or unsustainable RPC costs.
- Cost: ~$5-$50 per name registration/update
- Latency: ~12 second block time for finality
- Scale: Impossible for real-time social feeds
The Solution: Modular Data Availability
Offloading identity state and updates to a dedicated DA layer like Celestia, EigenDA, or Avail decouples storage cost from settlement security.
- Cost: Sub-cent transaction fees for profile updates
- Throughput: 10k+ TPS for social interactions
- Architecture: L1 for root ownership, DA for high-frequency data
The Indexer: The Graph & Subsquid
DA layers provide raw data; indexers like The Graph (Subgraphs) and Subsquid transform it into queryable APIs. They are the essential middleware for any usable identity layer.
- Performance: ~100ms queries vs. seconds scanning chain
- Decentralization: Indexer networks vs. centralized RPC providers
- Use Case: Powering Lens protocol feeds, ENS resolvers
The New Stack: L1 + DA + Indexer
The canonical architecture splits functions: Ethereum for root ownership and final settlement, Celestia for cheap social data availability, The Graph for performant queries. This is the only path to a billion-user social graph.
- Security: L1-grade for asset ownership
- Scalability: Web2-grade for user experience
- Example: Farcaster's storage on OP Stack + eventual DA
The ZK-Proof Cop-Out (And Why It's Not Enough)
Zero-knowledge proofs solve privacy but create a new bottleneck for global identity systems.
ZK-proofs are computationally expensive. Every identity verification requires generating a proof, which is a heavy cryptographic operation. This creates a direct cost and latency barrier for mass adoption.
Proof aggregation is the real bottleneck. Systems like Worldcoin's Orb or Polygon ID must aggregate millions of proofs. The verification cost scales linearly, making a global user base economically unviable on-chain.
State growth remains unsolved. A ZK-proof verifies a claim, but the persistent identity state (SBTs, credentials) still bloats the chain. This is the same data availability problem faced by rollups like Arbitrum and zkSync.
Evidence: A single Groth16 proof on Ethereum costs ~400k gas. At 10M users with weekly proofs, the annual verification cost exceeds $50M at current gas prices.
TL;DR for Protocol Architects
On-chain identity is hitting a wall: current models can't serve billions of users without breaking consensus or privacy.
The Problem: State Bloat Kills Composability
Storing identity credentials directly on-chain creates permanent, unprunable state. This leads to:\n- Exponential storage costs for nodes, centralizing infrastructure.\n- Crippled throughput as identity checks compete with DeFi/NFT transactions for block space.\n- Broken composability as dApps become reluctant to query bloated, expensive identity contracts.
The Solution: Zero-Knowledge Proofs & Off-Chain Attestations
Shift the paradigm from storing data to verifying claims. This is the core of zk-proofs and frameworks like Ethereum Attestation Service (EAS).\n- Constant-sized proofs verify complex credentials without revealing underlying data.\n- Off-chain issuance with on-chain verification slashes L1 footprint.\n- Selective disclosure enables privacy-preserving KYC via zk-verified credentials.
The Architecture: Layer 2 & Modular Identity Stacks
Scalability requires moving identity logic off the settlement layer. This mirrors the modular blockchain thesis.\n- L2/Appchain execution: Handle verification and revocation on high-throughput chains like Starknet or zkSync.\n- Shared attestation layers: Use EAS or Verax as a canonical registry, avoiding vendor lock-in.\n- Intent-based resolvers: Let users express goals (e.g., 'prove I'm accredited') with systems like UniswapX or Across.
The Trade-Off: Decentralization vs. Performance
You cannot maximize for Sybil resistance, privacy, and global scale simultaneously. Architects must choose a vertex.\n- Soulbound Tokens (SBTs): Maximize decentralization and composability, but sacrifice privacy and scalability.\n- zk-Proof Systems: Maximize privacy and scale, but introduce complex trusted setups and proof generation latency.\n- Centralized Attesters: Maximize scale and speed (e.g., Worldcoin), but reintroduce trust assumptions.
Get In Touch
today.
Our experts will offer a free quote and a 30min call to discuss your project.