ZK proofs are infrastructure because they separate computation from verification. This decoupling enables trustless off-chain execution, where a single proof validates a massive batch of transactions for networks like zkSync and Polygon zkEVM.
the-modular-blockchain-thesis-explained
Blog
Why Zero-Knowledge Proofs Are Becoming Infrastructure
ZKPs are no longer just for privacy. They are becoming a commoditized verification service, powering rollups, oracles, and data availability. This is the inevitable infrastructure shift driven by the modular blockchain thesis.
introduction
THE SHIFT
Introduction
Zero-knowledge proofs are transitioning from a cryptographic novelty to the foundational privacy and scaling layer for blockchains.
The scaling imperative drives adoption. The cost to generate a ZK proof is falling faster than the cost to execute the same computation on-chain, making ZK-rollups the endgame for Ethereum scaling versus optimistic rollups.
Privacy becomes programmable. Beyond scaling, ZK proofs enable private state for applications like Aztec Network and Aleo, moving beyond the naive transparency of most smart contracts.
Evidence: StarkWare's StarkEx prover generates proofs for dYdX and Sorare processing over 100M transactions, demonstrating production-scale throughput impossible on base Ethereum.
thesis-statement
THE ARCHITECTURAL SHIFT
The Core Thesis: Verification as a Service
Zero-knowledge proofs are transitioning from a niche cryptographic tool into a foundational, commoditized layer for trustless computation.
ZK proofs abstract trust. They allow one party to prove a statement's validity without revealing the underlying data, shifting the security model from social consensus to cryptographic verification.
This creates a new primitive: verifiable compute. Applications like zkRollups (Starknet, zkSync) and privacy protocols (Aztec) no longer build their own proof systems; they consume them from specialized providers like Risc Zero or Succinct.
The market values verification, not computation. The cost of generating a proof is trivial compared to the cost of verifying it across a decentralized network. This inverts the economic model of traditional cloud computing.
Evidence: Ethereum's Dencun upgrade reduced L2 data costs by ~90%, making the cost of posting a ZK validity proof to Ethereum the primary bottleneck and business metric for rollups.
key-trends
FROM RESEARCH TO UTILITY
The Three Drivers of ZK Commoditization
Zero-knowledge proofs are transitioning from academic novelty to foundational infrastructure, driven by three concrete market forces.
01
The Modular Stack: Specialization Breeds Commoditization
The monolithic ZK stack is fracturing into specialized, interoperable layers. This mirrors the L1/L2 evolution and creates a competitive market for each component.\n- Prover Marketplaces like RiscZero and Succinct commoditize proof generation.\n- Hardware Accelerators from Cysic and Ingonyama target specific proof systems (Groth16, Plonk).\n- Verification Contracts become a standardized, low-margin utility on every chain.
100x
Prover Competition
-90%
Cost Curve
02
The L2 Scaling Mandate: ZK-Rollups Demand Proofs-as-a-Service
Every major ZK-Rollup (zkSync, Starknet, Polygon zkEVM) requires a constant, reliable stream of cheap, fast proofs to finalize blocks. This creates a $1B+ annualized demand for proof generation.\n- Throughput is Revenue: Block time and gas cost are directly tied to prover performance.\n- Redundancy is Critical: Networks require multiple prover clients to avoid single points of failure, as seen in Ethereum's client diversity push.
~3s
Target Finality
$0.01
Target Cost/Tx
03
The Privacy & Compliance Use Case: ZKPs as a Regulatory Primitive
Institutions and regulated DeFi need auditable privacy. ZKPs enable compliance without exposing sensitive data, turning a niche feature into a core business requirement.\n- ZK-KYC: Protocols like Polygon ID and zkPass verify credentials off-chain.\n- Private Transactions: Aztec and Zcash demonstrate demand for shielded activity.\n- Proof of Solvency: Exchanges can prove reserves without revealing total holdings.
TradFi
New Market
Auditable
Compliance
PROOF SYSTEMS & PROVERS
The ZK Infrastructure Stack: A Comparative View
Comparing the core infrastructure layers enabling Zero-Knowledge applications, from proof systems to hardware acceleration.
| Feature / Metric | zk-SNARKs (e.g., Groth16, Plonk) | zk-STARKs (e.g., StarkWare) | zkVM / CPU (e.g., RISC Zero, SP1) | Hardware Accelerator (e.g., Ulvetanna, Cysic) |
|---|---|---|---|---|
Cryptographic Assumption | Trusted Setup (CRS) Required | Quantum-Resistant Hash Functions | Trusted Setup (CRS) Required | N/A (Accelerates Above) |
Proof Size | < 1 KB | ~45-200 KB | ~10-100 KB | N/A |
Verification Time (On-chain) | < 10 ms | ~100 ms | ~50 ms | N/A |
Prover Time (Example Op) | ~3 sec (for 1M constraints) | ~5 sec (for 1M constraints) | ~15 sec (for 1M guest instructions) | < 1 sec (for 1M constraints) |
Primary Use Case | Private payments (Zcash), Succinct verification | High-throughput L2s (StarkNet), Scalable proofs | General-purpose program verification, Ethereum L2s | Accelerating all proof systems for cost reduction |
Developer Tooling | Circom, SnarkJS | Cairo | RISC Zero zkVM, SP1 Rust SDK | APIs for Plonk, Groth16, Halo2 |
Recursive Proof Composition | ||||
EVM Bytecode Verification |
deep-dive
THE INFRASTRUCTURE SHIFT
From zkRollups to zkEverything: The Domino Effect
Zero-knowledge proofs are evolving from a scaling solution into a foundational primitive for all decentralized systems.
zkEVMs are the catalyst. The successful deployment of zkSync Era and Starknet proved general-purpose zk-provable execution is viable. This created a production-ready market for proof generation and verification hardware.
The domino effect is specialization. Dedicated zk co-processors like Risc Zero and Succinct now offer proofs for any computation, not just EVM states. This separates execution from verification as a service.
The endgame is zk-infrastructure. Every component—storage proofs with Brevis, oracles with HyperOracle, bridges with Polygon zkEVM—will integrate a zk layer. Trust assumptions shift from committees to math.
Evidence: The modular stack is forming. EigenLayer restakers secure Avail DA, which feeds data to zkRollups, whose proofs are verified by Espresso sequencers. ZK is the glue.
counter-argument
THE INFRASTRUCTURE TRAP
The Bear Case: Over-Engineering and Centralization
ZK technology's shift from application-specific logic to generalized infrastructure creates systemic complexity and centralization risks.
ZK proofs are becoming infrastructure. This transition moves the technology from a specialized tool for applications like zkSync or StarkEx into a foundational layer, analogous to how AWS abstracts compute. The result is a black-box dependency where entire ecosystems rely on a handful of proving systems like Risc Zero or Succinct.
Generalization introduces systemic risk. A bug in a general-purpose ZK VM like zkEVM or a proving stack like Jolt compromises every application built on it. This contrasts with isolated, application-specific circuits where failures are contained, creating a single point of cryptographic failure for the network.
Proving centralization is inevitable. The hardware and expertise required for high-performance proving (e.g., GPU/ASIC clusters) create economic moats. This centralizes trust in a few entities like Espresso Systems for sequencing or Ulvetanna for hardware, replicating the validator centralization seen in Ethereum's Lido.
Evidence: The Ethereum roadmap itself treats ZK as a core L1 primitive (EIP-4844, danksharding), cementing its infrastructure role. The proving market is consolidating, with teams like Nil Foundation and Polygon zkEVM competing on throughput benchmarks, not decentralization.
protocol-spotlight
FROM CRYPTOGRAPHIC CURIOSITY TO PUBLIC GOOD
Architects of the ZK Infrastructure Layer
Zero-knowledge proofs are evolving from niche privacy tech into the foundational trust layer for scalable, interoperable blockchains.
01
The Problem: The Data Availability Bottleneck
Rollups must post all transaction data on-chain, creating a massive and expensive data layer. This limits scalability and centralizes around a few data-heavy L1s like Ethereum.
- Celestia and EigenDA offer modular DA, but verification is still heavy.
- ZK proofs compress this: verify state transitions, not raw data.
100x
DA Cost Reduction
~128KB
Proof vs. GBs of Data
02
The Solution: zkEVMs as Universal Settlement
Projects like Scroll, Polygon zkEVM, and zkSync Era use ZK proofs to batch and verify EVM execution off-chain.
- Starknet and zkSync prove thousands of transactions in a single proof.
- Enables Ethereum to become a pure settlement layer with ~500ms finality, not 12 minutes.
3000+
TPS per Batch
-90%
User Fees
03
The Problem: Fragmented Liquidity & State
Hundreds of L2s and app-chains create isolated pools of capital and user experience. Bridging is slow, insecure, and expensive.
- LayerZero and Axelar rely on external validator security.
- Native cross-chain composability is broken.
$2B+
Bridge Hacks (2022-23)
5-20 min
Standard Bridge Delay
04
The Solution: ZK Light Clients & Proof Aggregation
Succinct Labs, Polygon AggLayer, and Avail use ZK proofs to create trust-minimized bridges and unified liquidity.
- A ZK proof can verify another chain's state transition in ~100ms.
- Enables shared security models and atomic cross-chain transactions.
~1s
Cross-Chain Finality
Trustless
Security Model
05
The Problem: Opaque & Inefficient Proving
Early ZK systems like Zcash were slow, specialized, and required custom circuits. Proving costs were prohibitive for general computation.
- Hardware acceleration (Accseal, Cysic) was a prerequisite for viability.
- Developer experience was a nightmare.
Minutes
Early Prove Times
$10+
Per Proof Cost
06
The Solution: General-Purpose Proving Networks
Risc Zero, SP1, and Lumoz abstract proving into a cloud service. Developers write in Rust or other mainstream languages.
- EigenLayer AVS models can decentralize provers.
- Turns ZK from a core competency into a commodity API, similar to AWS for compute.
< $0.01
Target Proof Cost
Sub-Second
Prove Time
risk-analysis
THE HIDDEN COSTS OF PROVING EVERYTHING
What Could Go Wrong? The ZK Infrastructure Bear Case
Zero-knowledge proofs promise a trustless future, but the path is paved with economic and technical landmines that could stall adoption.
01
The Prover's Dilemma: Centralization by Hardware
ZK-SNARKs and ZK-STARKs require specialized, expensive hardware (GPUs, FPGAs, ASICs) for performant proving. This creates a capital-intensive moat, centralizing prover power and recreating the miner oligopoly problem ZK was meant to solve.
- Proving a zkEVM batch can cost $0.50-$5.00 in compute, making micro-transactions untenable.
- Top-tier provers (e.g., Ulvetanna, Ingonyama) control disproportionate market share, creating single points of failure.
- The race for faster proofs mirrors the ASIC arms race, benefiting well-funded entities, not decentralized networks.
$0.50-$5.00
Proving Cost
Oligopoly
Risk
02
The Trusted Setup Ceremony: A Persistent Single Point of Failure
Most efficient ZK-SNARKs (Groth16, Plonk) require a one-time trusted setup. A compromised ceremony poisons all subsequent proofs, creating systemic risk. While 'ceremonies' (e.g., Zcash, Tornado Cash) use MPC, they remain vulnerable to sophisticated attacks and require perpetual social coordination.
- A single leaked toxic waste from a major ceremony could invalidate billions in secured assets.
- STARKs avoid this but at the cost of larger proof sizes and higher verification gas costs on Ethereum.
- The industry is betting on perpetual honesty in a system designed to eliminate trust.
Billions $
Systemic Risk
Perpetual
Coordination
03
The Complexity Trap: Inauditable Cryptography
ZK systems are built on cutting-edge, complex cryptography. Auditing a ZK circuit or a novel proving system (e.g., Nova, Boojum) requires PhD-level expertise. A single bug in a circuit compiler (like Circom or Halo2) or a proving library can lead to silent, undetectable failures where proofs verify for incorrect statements.
- The 2022 zk-bug in a popular library went unnoticed for months.
- Formal verification is slow and expensive, creating a gap between innovation and security.
- This creates a 'black box' problem where users must trust the reputation of a small cabal of developers.
Months
Undetected Bugs
Cabals
Trust Model
04
The Interoperability Illusion: Fragmented Proof Systems
The ZK landscape is a tower of Babel: zkEVMs (Scroll, zkSync, Polygon zkEVM), coprocessors (Axiom, Brevis), and L2s each use different proof systems, VMs, and verification contracts. This fragments liquidity, developer tools, and security assumptions, preventing network effects.
- A proof from Chain A is worthless on Chain B, requiring costly re-proving or trusted bridging.
- Verifier contracts on Ethereum Mainnet are non-upgradable and expensive, locking in potential vulnerabilities.
- The promise of a seamless 'ZK-o-sphere' is hindered by competing technical stacks vying for dominance.
Fragmented
Ecosystem
Locked-In
Verifiers
05
The Economic Dead Zone: Who Pays for Privacy?
General-purpose ZK-rollups pay for privacy/verification overhead that most users don't need. For public L2s, ZK is a costly scaling tool competing with Optimistic Rollups (Arbitrum, Optimism). The privacy use case (Aztec, Aleo) faces a demand problem: most DeFi/NFT activity is public by design. The value capture is unclear.
- ZK-rollup transaction fees are 2-5x higher than Optimistic equivalents, all else being equal.
- Privacy-preserving dApps struggle for TVL due to compliance fears and lack of composability.
- The infrastructure is being built for a market that may not materialize at scale.
2-5x
Fee Premium
Weak
Demand Signal
06
The Moore's Law Mirage: Stagnant Proving Times
Proof generation times have plateaued for complex transactions. Proving a simple swap takes ~seconds, but a full block of mixed transactions (DEX, lending, NFT mint) can take minutes on consumer hardware. This creates a latency ceiling for decentralized prover networks and user experience.
- zkEVM block times are often 5-10 minutes, compared to ~2 seconds for Solana or 12 seconds for Ethereum L1.
- Recursive proofs (Nova, Boojum) promise improvement but add another layer of complexity and unproven security.
- The 'instant finality' narrative ignores the practical latency of proof generation in real-world conditions.
5-10 min
Block Time
Minutes
Proving Latency
future-outlook
THE INFRASTRUCTURE LAYER
The 2025 Landscape: Invisible ZK
Zero-knowledge proofs are transitioning from a novel feature to the foundational, invisible plumbing of scalable blockchain systems.
ZK is now infrastructure. The technology shifts from a user-facing product to a developer-facing utility. Engineers now integrate ZK as a service from providers like Risc Zero or Succinct, not build it from scratch.
The proving market commoditizes. Specialized proving networks, such as =nil; Foundation and Espresso Systems, separate proof generation from execution. This creates a competitive market for the cheapest, fastest proof.
Interoperability becomes provable. Projects like Polymer and zkBridge use ZK proofs for trust-minimized cross-chain messaging, replacing multisig-based bridges like Multichain or Stargate.
Evidence: Polygon zkEVM processes over 1 million proofs daily, a 40x increase year-over-year, demonstrating the shift from theoretical to operational scale.
takeaways
ZK AS INFRASTRUCTURE
TL;DR for Busy CTOs and Architects
ZKPs are no longer a niche privacy tool; they are the critical substrate for scaling, interoperability, and trust-minimization.
01
The Problem: Ethereum's Data Bloat
Storing full transaction data on-chain is unsustainable. Rollups like Arbitrum and Optimism post compressed data, but even that costs ~$1M+ daily. The blockchain is becoming a database of receipts, not a computer.
- Solution: Validity Proofs (zk-Rollups).
- Key Benefit: Replace gigabytes of data with a ~1KB proof.
- Key Benefit: Enables secure, low-cost scaling without new trust assumptions.
~1KB
Proof Size
-99%
Data Cost
02
The Problem: Cross-Chain Security Theater
Bridges like LayerZero and Wormhole rely on external validator sets, creating $2B+ in hackable surface area. Multi-sigs and oracles are a temporary, risky patch.
- Solution: Light Clients + ZK Proofs.
- Key Benefit: Cryptographically verify state transitions of another chain.
- Key Benefit: Enables trust-minimized interoperability (e.g., zkBridge).
$2B+
Bridge Hacks
0
New Trust Assumptions
03
The Problem: Opaque Off-Chain Compute
Traditional cloud servers and keepers are black boxes. Protocols like Chainlink Functions or The Graph introduce centralization risk. You're outsourcing your core logic.
- Solution: ZK Coprocessors (e.g., Risc Zero, Axiom).
- Key Benefit: Prove arbitrary computation was executed correctly off-chain.
- Key Benefit: Enables complex DeFi logic (e.g., risk engines, on-chain ML) with Ethereum-level security.
10,000x
Compute Scale
L1 Security
Guarantee
04
The Problem: Privacy as a Public Good
Total transparency kills institutional adoption and creates MEV exploits. Mixers like Tornado Cash are blunt instruments and regulatory targets.
- Solution: Programmable Privacy (e.g., Aztec, Penumbra).
- Key Benefit: Selective disclosure of transaction details.
- Key Benefit: Enables compliant DeFi and shields users from predatory MEV.
$1B+
Annual MEV
Regulatory
Pathway
05
The Problem: Proving is Too Damn Slow
Early ZK systems (zk-SNARKs) required minutes to hours to generate a proof, making them useless for real-time apps. Hardware was the bottleneck.
- Solution: GPU/ASIC Provers & Parallelization.
- Key Benefit: Sub-second proof times for common operations.
- Key Benefit: Unlocks ZK for high-frequency trading and gaming (e.g., zkEVM rollups).
<1s
Proof Time
1000x
Speed-Up
06
The Problem: Centralized Sequencing
Rollups today have centralized sequencers—a single point of failure and censorship. This betrays decentralization promises.
- Solution: Decentralized Prover Networks (e.g., Espresso, Lagrange).
- Key Benefit: Distribute proof generation across many nodes.
- Key Benefit: Creates credibly neutral infrastructure and eliminates sequencer risk.
1
Single Point of Failure
N/A
Censorship Resistance
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