Skip to main content

This site is for educational purposes only. Nothing here constitutes financial advice.

Topic 43 of 189

State Pruning and Expiry

Why Ethereum's node storage needs have grown to terabytes, what 'archive,' 'full,' and 'light' nodes actually store, and how proposals like EIP-4444 and new state-tree designs (verkle or binary) aim to keep node hardware accessible for years to come.

Beginner
8 min readUpdated November 2026Block Clarity Hub Editorial Team

The basics

What Lives in Blockchain State

A blockchain's 'state' is everything you need to know to validate the next block: account balances, contract storage, nonces, code. The state grows every time someone deploys a contract, creates an NFT, or writes data on-chain. Over time, it just keeps getting bigger — because old data doesn't naturally get removed. A full Ethereum node that keeps the complete chain history needs close to 2 TB of disk (as of September 2026), and archive nodes that keep all historical state need from about 2 TB to more than 12 TB depending on the client.

Three Kinds of Nodes

Not every node stores everything. Archive nodes store the full historical state at every block — useful for analytics, but huge (multiple TB on Ethereum). Full nodes store the blockchain data and recent state but prune older historical state — most validators run these (roughly 1.7-2.2 TB on Ethereum mainnet with full chain history, as of September 2026). Light nodes store almost nothing, just block headers, and ask full nodes for any specific data they need. The trade-off is storage vs trust.

Why This Is a Problem

If running a node requires expensive hardware, fewer people will run them, and the network becomes more centralised. Ethereum already asks a lot of home setups — ethereum.org recommends a fast 4 TB NVMe SSD and 32 GB of RAM for a full node. The community is working on solutions to keep this from getting worse, including state pruning (delete what we can), state expiry (push old state off the main path), and Verkle trees (smaller cryptographic proofs).

  • Archive node: full history, multiple TB — for analytics and explorers
  • Full node: blockchain data + recent state, ~1.7-2.2 TB on Ethereum with full history (Sept 2026) — for validators
  • Light node: just headers, asks others for data — for phones and lightweight clients
  • The growth problem: state never shrinks naturally; eventually nodes get too expensive

Key Takeaways

  • State is everything needed to validate the next block; it grows monotonically
  • A full Ethereum node with complete history needs close to 2 TB (Sept 2026); archive nodes need 2 TB to 12 TB+
  • Running a node requires storage that's getting harder to fit on consumer hardware
  • The community is working on pruning, expiry, and proof-system upgrades to keep hardware accessible

Going deeper

EIP-4444 — Historical Data Expiry

EIP-4444 proposes that nodes only have to store recent history (the current draft sets 14,299 epochs, roughly two months of blocks). Older blocks would be expired off the network — full nodes wouldn't be required to serve them. The full history would still exist in archive nodes, ipfs-style decentralised storage, and institutional archive providers, but the network's baseline requirement would shrink. Partial history expiry (dropping pre-Merge blocks) has been supported by all Ethereum execution clients since July 2025, but full, rolling expiry is still ongoing work and EIP-4444 remains a Draft.

State Expiry (More Aggressive)

Beyond historical block data, the 'state expiry' proposals address growing state itself. The idea: accounts that haven't been touched in N years get expired from the active state. To resurrect them, you'd provide a cryptographic proof that the old account existed. This dramatically caps state growth — most accounts in existence have never been touched after their creation. State expiry has been researched for years; the design space is complex and a specific path hasn't been selected yet.

Verkle Trees — Smaller Proofs

Ethereum's state is currently stored in a Merkle Patricia tree, which produces fairly large proofs (a few KB per account access). Verkle trees use vector commitments to shrink those proofs: in ethereum.org's illustration, a witness covering 1,000 leaves is about 150 kB in a Verkle tree versus about 3.5 MB in a Merkle trie. This enables 'stateless clients' — nodes that don't store state but instead receive small proofs alongside each block proving the state changes were valid. The verkle proposal (EIP-6800) is listed as Stagnant on eips.ethereum.org, and a newer Draft, EIP-7864, proposes a unified binary tree instead; ethereum.org's roadmap pages still describe verkle trees as the route to statelessness.

Different from Layer-2 Compression

State pruning is about reducing what nodes have to store. L2 rollups are about reducing how much state has to be on L1 at all. They're complementary: even with L2s shifting application state off L1, L1 still grows from the rollup commitments themselves, plus accounts created directly on L1.

Key Takeaways

  • EIP-4444: nodes only have to serve recent history (about two months in the current draft), shrinking the baseline storage requirement
  • State expiry: dormant accounts get expired from active state, with proof-based resurrection
  • Verkle trees: vector commitments produce tiny proofs, enabling stateless clients
  • Layer-2 is complementary, not a replacement — L1 still needs state management

Under the hood

Stateless Clients

The endgame of these changes is 'stateless clients' — nodes that don't store state at all. Instead, every block carries a small set of cryptographic 'witnesses' (proofs of the state slots the block reads or writes). A node verifies the witnesses, applies the block, and discards. This makes running a node essentially free in terms of storage and lets validators run on phone-class hardware. Requires a witness-friendly state tree (verkle, or a binary tree as in EIP-7864) for small witnesses, plus protocol changes for witness generation and propagation. Multi-year effort.

Portal Network and Decentralised History

If full nodes stop serving old history (EIP-4444), where does the old data live? The Portal Network is one answer: a peer-to-peer overlay network where light clients store small shards of historical data and serve each other on demand. It's like BitTorrent for blockchain history. ethereum.org still describes it as in development. The Ethereum Foundation's July 2025 partial-expiry announcement names institutional archive providers and torrents as other distribution channels.

The Other Modular Chains

Solana takes a different approach: it prices state. Every account must hold a refundable minimum balance proportional to its data size to remain onchain, which puts a cost on state growth. Different chains have made different choices on the spectrum from 'never delete anything' (Ethereum's current state) to pricing state storage directly (Solana).

Why the Roadmap Is Slow

Verkle, state expiry, and stateless clients have been discussed for years and won't ship for years more. Why so slow? Because they're protocol changes that affect every client, every wallet, every contract that depends on Merkle proofs (a lot of L2 designs do), and every archive service. Coordinating that change requires extensive specification, multi-client implementation, testnet rollout, and careful migration design. Ethereum prioritises not breaking things; the cost is slow infrastructure evolution.

Watch the Geth Snap-Sync Time

A practical indicator of state growth: how long does it take Geth (the most common Ethereum client) to snap-sync from scratch? Longer syncs and bigger disks are felt as a real centralisation pressure. State management upgrades will be felt as a reversal of this trend.

Key Takeaways

  • Stateless clients are the long-term goal: nodes verify proofs, store nothing
  • Portal Network is a proposed p2p solution for serving expired historical data
  • Solana takes a different approach: a refundable minimum balance per account
  • Roadmap is slow because protocol changes coordinate across every client, wallet, and L2
  • Geth snap-sync time is a practical indicator of state-growth pressure

Related Content

EIP-4844 and Proto-Danksharding

How Ethereum's March 2024 Dencun upgrade introduced blob space — a new transaction type that cut rollup data costs by ~10x and set the stage for full danksharding.

Account Abstraction (ERC-4337)

How ERC-4337 brings smart-contract wallets, social recovery, gasless transactions, and arbitrary signature schemes to Ethereum without changing the protocol — and why every wallet UX of the next decade will use it.

Data Availability Sampling

How light nodes can be cryptographically confident that a block's full data was published — without downloading it — and why this is the key unlock for Ethereum's full danksharding and the modular blockchain stack.

Finality and Fork Handling

What it means for a transaction to be 'final,' why different chains finalise differently, how reorgs happen, and the MEV incentives that complicate the picture.

ECDSA vs EdDSA vs BLS

The three signature schemes you'll meet across the crypto stack — what each does well, what tradeoffs they impose, and why Ethereum uses three of them simultaneously.

zk-SNARK vs zk-STARK vs PLONK

How the three major proof-system families compare on trusted setup, proof size, prover cost, and quantum resistance — and which production rollups picked which.

Threshold Signatures and MPC

How t-of-n threshold signatures and multi-party computation let multiple parties sign together without any one holding the full key — the cryptography behind Fireblocks and modern institutional custody.

Verifiable Random Functions

How VRFs produce randomness that's both unpredictable before commitment and cryptographically verifiable after — enabling fair lotteries, leader election, and on-chain randomness without trusted parties.

References & further reading