Free 30-min Web3 Consultation
Book Consultation
Smart Contract Security Audits
View Audit Services
Custom DeFi Protocol Development
Explore DeFi
Full-Stack Web3 dApp Development
View App Services
Free 30-min Web3 Consultation
Book Consultation
Smart Contract Security Audits
View Audit Services
Custom DeFi Protocol Development
Explore DeFi
Full-Stack Web3 dApp Development
View App Services
Free 30-min Web3 Consultation
Book Consultation
Smart Contract Security Audits
View Audit Services
Custom DeFi Protocol Development
Explore DeFi
Full-Stack Web3 dApp Development
View App Services
Free 30-min Web3 Consultation
Book Consultation
Smart Contract Security Audits
View Audit Services
Custom DeFi Protocol Development
Explore DeFi
Full-Stack Web3 dApp Development
View App Services
network-states-and-pop-up-cities
Blog

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.

introduction
THE SCALABILITY CRISIS

The Coming Data Avalanche

Global on-chain identity systems will generate more data than current L1s can process, creating a new bottleneck.

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.

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.

deep-dive
THE IDENTITY BOTTLENECK

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.

THE SCALABILITY CRISIS

Data Load Projections: The Billion-User Reality

Comparing the data load and infrastructure demands of leading on-chain identity paradigms at 1B+ users.

Metric / CapabilitySoulbound 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

protocol-spotlight
SCALING IDENTITY

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.

01

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
~3M
Names
~12s
Latency
02

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
10k+
TPS
<$0.01
Cost/Tx
03

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
~100ms
Query Time
100%
Uptime SLA
04

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
1B+
User Capacity
-99%
Cost vs. L1
counter-argument
THE SCALABILITY CONSTRAINT

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.

takeaways
THE SCALABILITY CRISIS

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.

01

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.

100GB+
Node Bloat
>50%
Gas Overhead
02

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.

~1KB
Proof Size
99%
Less State
03

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.

10k TPS
L2 Capacity
$0.001
Cost Per Verify
04

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.

Pick 2
Of 3
~2s
ZK Prover Latency
ENQUIRY

Get In Touch
today.

Our experts will offer a free quote and a 30min call to discuss your project.

NDA Protected
24h Response
Directly to Engineering Team
10+
Protocols Shipped
$20M+
TVL Overall
NDA Protected Directly to Engineering Team
On-Chain Identity Scalability Crisis: Why L1s Will Fail | ChainScore Blog