Skip to main content

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

Topic 43 of 179

State Pruning and Expiry

Why Ethereum's state has grown to hundreds of gigabytes, what 'archive,' 'full,' and 'light' nodes actually store, and how proposals like EIP-4444 and Verkle trees aim to keep node hardware accessible for years to come.

Beginner
8 min readUpdated July 2026Block Clarity Hub Editorial Team

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. Ethereum's full state is hundreds of gigabytes; the full historical archive (everything since genesis) is multiple terabytes.

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 current state and recent history but prune older history — most validators run these (~1.5 TB on Ethereum mainnet). **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 is already at the edge of what comfortable home setups can run — a $2000 PC can do it but barely. 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: current state + recent history, ~1.5 TB on Ethereum — 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
  • Ethereum's state is hundreds of GB; full archive is multiple 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

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, Lit Protocol, 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