Why State Bloat Forces a Choice: Identity or Scalability

State is the bottleneck. Every account, balance, and NFT is global state that every node must store and validate, creating an exponential scaling wall for monolithic L1s like Ethereum and Solana.

Scalability demands state fragmentation. High-throughput solutions like Arbitrum and Solana Virtual Machines shard execution, but this fragments user identity and assets across isolated environments, breaking composability.

Sovereign identity resists fragmentation. Wallets like Ethereum EOAs and smart accounts (ERC-4337) anchor identity to a single chain, making cross-chain activity a UX nightmare of bridging and gas management.

Evidence: The proliferation of over 100 active L2/L3 networks has turned a unified web3 into a liquidity archipelago, where user capital and identity are trapped in silos.

State is the bottleneck. Every account balance, NFT ownership, and smart contract variable is global state that every node must store and process, creating a hard ceiling on throughput.

Persistence demands consensus. For a user's identity and assets to be permanent, the network must achieve Byzantine consensus on every state change, which is inherently slow and expensive.

Scalability requires ephemerality. High-throughput systems like Solana or Arbitrum Nitro achieve performance by treating state as temporary; validators prune old data, sacrificing guaranteed long-term access.

The identity-scalability trade-off is absolute. You cannot have a system where every user's complete history is permanently available to all and also scales to millions of transactions per second. Ethereum's archive nodes versus Solana's ledger size exemplify this dichotomy.

State is the bottleneck. Every transaction modifies the global ledger, creating a data footprint that every node must store and process. This state bloat imposes a hard limit on scalability, forcing a choice between two divergent architectural paths.

Path 1: Global Identity Layer. This model, exemplified by Ethereum's L1, prioritizes secure, shared state for identity primitives like ENS domains and token balances. It sacrifices raw throughput to maintain a single source of truth, making it the settlement and coordination layer for rollups like Arbitrum and Optimism.

Path 2: High-Throughput Execution. This model, seen in Solana and monolithic L1s, optimizes for transaction speed by treating state as local and disposable. It achieves scale by minimizing global consensus overhead, but fragments identity and composability, creating silos that require bridges like Wormhole and LayerZero.

Evidence: Ethereum's state size exceeds 1 TB, growing ~50 GB/year, while Solana's validator requirements demand 1 TB of RAM. This divergence proves you cannot optimize for both universal state and unbounded scalability simultaneously.

State expiry and EIP-4444 are not cures. They are pruning mechanisms that shift the burden. EIP-4444 deletes historical data after one year, but the active state continues its exponential growth. State expiry makes old, inactive state inaccessible, requiring users to provide proofs to revive it, which is a UX and complexity nightmare.

The trade-off is permanent. The core design forces a choice: a globally accessible state for identity or a pruned, fragmented state for scalability. Protocols like Ethereum and Solana are on opposite ends of this spectrum. A chain cannot optimize for both without architectural compromise.

Execution clients still choke. Even with pruning, the execution layer's working set must be in RAM for performance. The Verkle tree transition helps, but the fundamental data structure for a global computer remains a bottleneck. This is why zk-rollups and validiums push state off-chain.

Evidence: Ethereum's state size grows by ~50 GB/year. After EIP-4444, nodes still need to process and store this annual growth. A pruned Geth node today requires ~800 GB of SSD. The requirement for fast storage increases hardware costs and centralizes node operation.