Why State Expiry Is a Node Operator's Necessity, Not a Choice

Every new account and smart contract byte is a permanent, mandatory liability for every full node. This creates a centralizing force, pricing out smaller operators and creating systemic fragility.\n- Storage costs for Ethereum's state have grown to ~650 GB+ and increase by ~50 GB/year.\n- Sync times for new nodes can take days to weeks, a critical failure for network resilience.

Prune historical state data older than a certain period (e.g., 1 year) from execution clients, requiring consensus-layer proofs (via Portal Network) for reactivation. This breaks the infinite growth curve.\n- Reduces perpetual storage burden by ~90%+ for node operators.\n- Enables light client verification of expired state, preserving decentralization.\n- Critical path for Stateless Ethereum and Verkle Trees.

Bitcoin's UTXO set is self-cleaning; spent outputs are discarded. Ethereum's account-based model accumulates 'dust' accounts and dead contract storage forever. This fundamental design difference makes state growth a uniquely critical problem for Ethereum and its L2s.\n- UTXO Set: Grows with adoption but is bounded by economic activity.\n- Account State: Grows monotonically, a strict superset of all historical data.

Assuming hardware advances will outpace state growth ignores the economic reality of running a node. The requirement for high-performance SSDs and abundant RAM creates a prohibitive cost floor.\n- Node operation shifts from a broadly accessible public good to a capital-intensive professional service.\n- This directly undermines the censorship-resistance and sovereignty guarantees of a decentralized network.

Every optimistic and ZK rollup (Arbitrum, Optimism, zkSync) replicates the state growth problem on its own chain, then periodically writes a compressed proof back to L1. The cumulative state burden across the ecosystem is multiplicative, not additive.\n- An L2's full node must store its own growing state plus the cost of verifying L1 data.\n- Without state expiry, the rollup scaling thesis hits the same hardware wall.

The choice is binary. Without a mechanism like state expiry, the network will inevitably centralize around a few large infrastructure providers (e.g., AWS, centralized RPCs). This is a direct attack on the security model.\n- Historical data can move to decentralized networks (Portal Network, BitTorrent, IPFS).\n- Active state remains lightweight and globally verifiable, preserving a permissionless node layer.

Unchecked state growth forces node requirements beyond consumer hardware, centralizing validation to a few professional operators. This kills decentralization and network resilience.

• Current Ethereum state is ~1TB+, growing at ~50-100GB/year.
• SSD wear becomes a major cost, with ~1PB+ of writes over a drive's lifetime.
• Sync times for new nodes stretch to weeks, making recovery from attacks or black swan events nearly impossible.

State bloat directly increases the cost of every transaction. More state means slower Merkle Patricia Trie lookups, higher witness sizes, and ultimately, a hard ceiling on throughput.

• Witness data for a simple transfer can balloon, clogging block space.
• Gas costs for SLOAD/SSTORE become prohibitive for dApps, stifling innovation.
• Without expiry, the network faces permanent congestion as a baseline condition, not a peak event.

The promise of 'archival nodes will store everything' is a dangerous crutch. It creates a fragile, two-tiered system where liveness depends on a handful of expensive, centralized services like Infura, Alchemy, and QuickNode.

• Relying on 3rd-party RPCs reintroduces the very points of failure crypto aims to eliminate.
• Data availability for expired state becomes a centralized rent-seeking opportunity.
• Protocol upgrades (like Verkle trees) can only delay, not solve, the fundamental growth problem.

Verkle trees and stateless clients are critical, but they only address verification, not storage. They shift the burden to block producers who must still hold the full, ever-growing state.

• Block builders become the new centralization bottleneck, as seen in PBS/MEV-Boost dynamics.
• Witness sizes, even with Verkle trees, grow with state, impacting p2p network bandwidth.
• This is a half-solution that fails to address the root cause: infinite accumulation of junk state.

Newer L1s and L2s like Solana, Sui, and Monad are architecturally designed for state management from day one. Ethereum's inertia on this issue cedes a key performance and developer mindshare advantage.

• Solana's aggressive state expiry via Epoch boundaries is a feature, not a bug.
• Modular chains that outsource execution (like Celestia rollups) can adopt expiry faster.
• Delay makes Ethereum the legacy chain struggling with its own success, while competitors scale cleanly.

Postponing state expiry guarantees a more painful, contentious, and ecosystem-splitting hard fork later. The longer we wait, the more dApps and billions in TVL become dependent on perpetual state, making the transition catastrophic.

• Contract breakage becomes a massive migration nightmare, worse than the DAO fork.
• Community consensus will fracture between node operators and dApp developers.
• Proactive expiry via EIP-4444 or similar is the only way to manage this transition with minimal disruption.