ZKPs verify, not compress. A validity proof confirms a state transition is correct, but the full historical state data must remain accessible for new proofs and sync. This creates a data availability problem identical to monolithic chains.
solana-and-the-rise-of-high-performance-chains
Blog
Why Zero-Knowledge Proofs Alone Can't Solve State Growth
ZK proofs are cryptographic magic for verifying execution, but they are silent on the foundational problem of who stores and serves the ever-growing blockchain state. This analysis argues that without architectures like Solana's aggressive state management, ZK systems merely shift the bloat burden to data availability layers like Celestia, creating a new centralization vector.
introduction
THE STATE BOTTLENECK
The ZK Mirage: Verification ≠State Management
Zero-knowledge proofs verify computation but do not inherently compress or manage the underlying state data, creating a fundamental scalability ceiling.
Proof generation requires state. Provers for zkEVMs like Polygon zkEVM or zkSync Era must fetch the entire world state to generate a proof. This process is I/O-bound, making state growth the primary bottleneck for proving speed, not cryptographic overhead.
State is the new consensus. Networks like Celestia and EigenDA exist because storing state is the real cost. A ZK rollup using a validity proof still depends on an external data availability layer for its raw inputs, divorcing verification from data management.
Evidence: Starknet's State Diff Size. Starknet's state diffs, the data needed to reconstruct state, are often larger than the proofs themselves. The proof is the certificate, but the state is the cargo—and the cargo's size determines the shipping cost.
key-trends
WHY ZKPS ARE NECESSARY BUT NOT SUFFICIENT
The State Growth Trilemma
Zero-Knowledge Proofs compress execution, but the blockchain's fundamental state—the ledger of who owns what—still grows linearly and must be stored by every node.
01
The Problem: Verifying History vs. Storing State
ZKPs like zk-SNARKs and zk-STARKs are brilliant for compressing and verifying transaction execution (e.g., zkRollups). However, they do not compress the resulting state—the account balances and smart contract storage that nodes must hold to process new blocks. The state size for Ethereum is ~200GB+ and growing, a burden for node operators.
200GB+
Ethereum State
0%
ZK State Compression
02
The Solution: Stateless Clients & State Expiry
The endgame is to make nodes stateless. Clients would only need a small cryptographic commitment (a Verkle Tree root) to verify blocks, using witnesses provided by block producers. Protocols like Ethereum's Verge and Celestia's Data Availability layers are prerequisites. Complementary proposals like state expiry (EIP-4444) would prune old, inactive state, capping growth.
- Key Benefit: Node requirements drop from terabytes to megabytes.
- Key Benefit: Enables ultra-light clients and better decentralization.
MBs
Node Footprint
EIP-4444
Pruning Mechanism
03
The Bottleneck: Data Availability is Non-Negotiable
Even with a ZK-validated block, the underlying transaction data must be available for reconstruction and fraud proofs. This is the Data Availability (DA) Problem. Solutions like EigenDA, Celestia, and Avail provide scalable, dedicated DA layers, but they represent an additional cost and complexity layer. Without robust DA, ZK proofs are useless—you can't prove what you can't see.
- Key Constraint: DA bandwidth dictates maximum TPS.
- Key Trade-off: Security vs. cost of external DA.
~16KB
DA Sample per Block
$0.xx per MB
DA Cost (est.)
04
The Architectures: Monolithic vs. Modular Chains
This trilemma forces a design choice. Monolithic chains (e.g., Solana, Sui) keep execution, settlement, consensus, and DA in one layer, optimizing for performance at the cost of state bloat. Modular chains (e.g., Ethereum + Rollups, Celestia rollups) separate these functions, using ZK for execution proofs and specialized layers for DA/consensus, accepting higher latency for sustainable scaling.
- Key Insight: ZK is the execution engine in a modular stack.
- Key Trend: ZK co-processors (Risc Zero, SP1) for off-chain computation.
Monolithic
All-in-One
Modular
Specialized Layers
deep-dive
THE SCALING BOTTLENECK
From Execution Prover to State Consumer
ZK proofs verify execution but shift the state data availability burden, creating a new bottleneck for scaling.
ZK proofs are not data solutions. They compress transaction validity into a succinct proof, but the prover must still process the full input data. This moves the bottleneck from on-chain execution to off-chain data availability and access.
The state consumer problem emerges. A ZK-rollup verifier only checks a proof, but any node rebuilding state—like an indexer for The Graph or a bridge like LayerZero—must fetch and process the full historical data. This requires a robust data availability layer.
Data availability dictates security. Without guaranteed data access, a malicious sequencer could withhold transaction data, making state unverifiable despite a valid proof. Solutions like Celestia, EigenDA, and Ethereum's danksharding address this core dependency.
Evidence: StarkNet's roadmap prioritizes Volition mode, letting apps choose between Ethereum and alternative DA layers, proving that proof verification and data storage are decoupled scaling challenges.
THE STATE GROWTH PROBLEM
Architectural Trade-offs: ZK Rollups vs. Monolithic Chains
Comparing how different architectures manage the fundamental challenge of blockchain state growth, which impacts node requirements, decentralization, and long-term scalability.
| Feature / Metric | ZK Rollup (e.g., zkSync, StarkNet) | Monolithic L1 (e.g., Ethereum, Solana) | Modular L1 (e.g., Celestia, Avail) |
|---|---|---|---|
State Growth Rate | Linear to user activity on L2 | Exponential to global network activity | Zero (Data Availability only) |
Full Node Hardware Cost (Annual Est.) | $500 - $2,000 | $15,000 - $50,000+ | $100 - $500 |
State Synchronization Time (from genesis) | < 1 hour |
| < 10 minutes |
Primary State Storage Burden | Sequencer & Provers | All Full Nodes | Data Availability Sampling Nodes |
State Pruning / History Expiry | Easier (off-chain data availability) | Extremely difficult (consensus-critical) | Native (only headers persist) |
Witness Data for Proofs | Required (circuit-specific) | Not Required | Not Required |
Trust Assumption for State Validity | ZK Validity Proof | Economic Security (Full Nodes) | Data Availability Proofs |
protocol-spotlight
ZK-PROOF LIMITS
The New Bottleneck: Data Availability Layers
Zero-Knowledge proofs compress execution, but they don't compress the underlying data needed to rebuild the chain's state.
01
The Problem: ZK Validity != Data Availability
A ZK proof verifies a state transition is correct, but it doesn't publish the data for that transition. Without the data, new nodes cannot sync, and users cannot reconstruct their funds. This creates a data availability problem that threatens decentralization.
- State Bloat: L2 state grows ~1-2 TB/year, but ZK proofs are only ~45 KB.
- Trust Assumption: Users must trust a sequencer to have the data, breaking censorship resistance.
- Sync Failure: New validators cannot join the network without the full transaction history.
45 KB
Proof Size
1-2 TB
Annual State Growth
02
The Solution: Dedicated DA Layers (Celestia, Avail, EigenDA)
Specialized blockchains that exist solely to order and guarantee the availability of transaction data. They decouple data publishing from execution, allowing rollups to scale independently.
- Cost Scaling: DA costs drop by ~99% vs. posting to Ethereum L1.
- Modular Design: Enables sovereign rollups that control their own execution and settlement.
- Security via Sampling: Light clients can probabilistically verify data is available using Data Availability Sampling (DAS).
-99%
DA Cost
10-100x
Throughput Gain
03
The Trade-Off: Security vs. Sovereignty
Choosing a DA layer is a direct trade-off between Ethereum's high security and a modular chain's lower cost and flexibility. This defines the modular blockchain stack.
- Ethereum (High Security): DA via calldata/blobs, inherits L1 consensus. High cost, high assurance.
- Celestia/Avail (High Sovereignty): Optimized for cheap, high-throughput DA. New, lighter security model.
- EigenDA (Hybrid): Uses Ethereum restaking for cryptoeconomic security, but offloads data ordering.
$1B+
Restaked Security
3-5s
Finality Time
04
The Future: Proof-Carrying Data & Volitions
Next-gen architectures like zkPorter and Validium use off-chain DA committees with ZK proofs of availability. This pushes the DA problem into a new trust spectrum.
- Validium: Uses a Proof-of-Stake DA committee. Faster/cheaper than rollups, but introduces a liveness assumption.
- Volition: A user's choice per transaction: store data on-chain (rollup) for security or off-chain (validium) for cost.
- Proof-Carrying Data: Projects like Succinct are exploring ZK proofs that also guarantee data availability.
-90%
vs. Rollup Cost
2
Trust Models
future-outlook
THE SCALING BOTTLENECK
The Path Forward: Hybrid Architectures & State Markets
ZK proofs compress execution but not state, forcing a fundamental architectural shift toward hybrid models and explicit state pricing.
ZK proofs are not a panacea. They compress computation and verification, but the historical state data they attest to still grows linearly. A ZK-rollup's prover must still access this ever-expanding state to generate proofs, creating a persistent bottleneck.
The solution is hybrid architectures. Systems like EigenDA and Celestia separate data availability from execution, while zkSync and Starknet explore volition models. This allows applications to choose their own security-cost trade-off for state storage.
This necessitates state markets. Persistent state becomes a priced resource. Protocols like Fuel and Solana already implement state rent. The future is explicit state pricing, where users pay for the footprint they create, moving beyond pure gas models.
Evidence: Starknet's state grew 300% in 2023. Without new models, node hardware requirements become prohibitive, recentralizing the network.
takeaways
THE ZK STATE BLIND SPOT
TL;DR for CTOs & Architects
ZKPs verify computation but are silent on the data they compute over. Unchecked state growth remains the existential threat to blockchain scalability.
01
The Problem: Proving ≠Pruning
A ZK-SNARK proves a state transition is valid, but does nothing to reduce the underlying data. The historical state still grows linearly with each block, creating an ever-increasing burden for nodes.\n- Validity ≠Viability: A chain can be perfectly verified yet impossible to sync.\n- Node Churn: Full nodes require terabytes of SSD, centralizing infrastructure.
~2 TB
Ethereum Archive
Linear
Growth Rate
02
The Solution: Statelessness + State Expiry
Decouple execution from full historical storage. Clients verify blocks using witnesses (proofs of state membership) instead of holding the entire state. Pair this with EIP-4444-style state expiry to bound growth.\n- Witness Size: The new bottleneck (~1-10 MB/block).\n- Verkle Trees: Essential for compact witness construction, replacing Merkle-Patricia.
>99%
State Discarded
MBs not GBs
Client Burden
03
The Bridge: Recursive Proofs & L2s
Recursive ZK proofs (e.g., zkSync, Starknet) can compress many L2 blocks into a single proof posted to L1. This amortizes cost but merely shifts the state problem. The L2 sequencer still faces the same data avalanche.\n- Data Availability: The real cost driver, solved by EigenDA, Celestia, or danksharding.\n- Sovereign Rollups: Take full responsibility for their own state, escaping L1 constraints.
~100x
Cost Compression
DA Layer
Critical Dependency
04
The Trade-off: Decentralization vs. Finality
Aggressive state pruning (e.g., Monad, Solana) achieves high throughput by making historical data optional. This creates a liveness/finality trade-off: you can't prove asset ownership from pruned history without a trusted archive.\n- Archivist Networks: Essential but centralized (e.g., Google Bigtable for Solana).\n- ZK Proof of History: A potential fix, making the archive's work verifiable.
10k+ TPS
Throughput Target
Trusted
Archive Assumed
ENQUIRY
Get In Touch
today.
Our experts will offer a free quote and a 30min call to discuss your project.
NDA Protected
Confidentiality24h Response
Time to ValueDirectly to Engineering Team
No Sales Fluff10+
Protocols Shipped
$20M+
TVL Overall