zkverify-context

name	zkverify-context
description	Guide developers through brainstorming ZK use cases, understanding zkVerify benefits, choosing the right proof system (Groth16, Noir, Risc Zero, SP1, Plonky2, EZKL, Fflonk), and designing architecture for privacy apps, zkML/AI, and cross-chain bridges. Use when users mention zkVerify, ZK proofs, privacy applications, proof verification, or want to explore adding ZK capabilities to their projects.

zkVerify Ideation Guide

Help developers ideate, understand, and design zero-knowledge proof applications using zkVerify - a specialized L1 blockchain for ZK proof verification.

zkVerify Value Proposition

Cost Reduction

• 100-1000x cheaper than verifying proofs on Ethereum
• Ethereum verification: 200,000-300,000 gas (~$20-60 during congestion)
• zkVerify: Fraction of the cost with stable, predictable pricing
• Market context: $100M+ in verification costs for zkRollups in 2024, growing to $1.5B by 2028

Native STARK Support

• Verify STARK proofs directly without wrapping in Groth16
• Eliminates latency from recursive SNARK conversion
• Supports zkVMs (Risc Zero, SP1) natively

Multi-Proof Architecture

• Single chain supports 8 proof systems
• Future-proof: add new verifiers via pallets
• Aggregation across proof types

Proof System Selection

When helping users choose a proof system, consider:

Quick Selection Guide

Use Case	Recommended Proof System	Why
General circuits	Groth16 (BN128/BN254)	Most mature, smallest proofs, widely used
zkML / AI inference	EZKL	Purpose-built for ML models
General computation	Risc Zero or SP1	Write Rust, no circuit knowledge needed
Noir-based apps	UltraHonk	Modern, developer-friendly DSL
High-throughput	Plonky2	Fast proving, recursive-friendly
Polygon zkEVM	Fflonk	Polygon-compatible

Proof System Details

Reference the detailed comparison in proof-selection.md.

Use Case Categories

1. Privacy Applications

• zkEmail: Verify email ownership without revealing content
• Identity protocols: Galxe Identity, zkPassport, age verification
• Private voting: Verifiable elections without revealing votes
• Confidential transactions: Prove solvency without revealing balances

2. zkML / AI Applications

• ML inference verification: Prove model output is correct
• Data provenance: Verify AI training data integrity
• Confidential AI: Run ML on private data with verifiable results

3. Cross-Chain Bridges

• Light client bridges: Verify consensus proofs across chains
• State proofs: Prove storage/balance on source chain
• Message verification: Verify cross-chain messages

4. Gaming & Entertainment

• Hidden information games: Poker, battleship with secret state
• Verifiable randomness: Provably fair game mechanics
• Anti-cheat: Prove game actions without revealing strategy

5. TEE Verification

• Attestation wrapping: Wrap TEE proofs in zkVM (Risc Zero)
• Hardware verification: Prove secure execution environment

See detailed use cases in use-cases.md.

Architecture Patterns

Pattern 1: Direct Verification

[Your App] → [Generate Proof] → [zkVerify Chain] → [Query Result]

Best for: Testing, zkVerify-native apps, internal verification

Pattern 2: Cross-Chain Attestation

[Your App] → [Generate Proof] → [zkVerify Chain] → [Aggregation] → [L1 Contract] → [Verify Merkle Proof]

Best for: dApps on Ethereum/Base/Arbitrum needing cheap proof verification

Pattern 3: Hybrid Architecture

[L1 dApp] → [Critical proofs: L1 verify] + [Bulk proofs: zkVerify]

Best for: High-volume apps with mixed verification requirements

See detailed patterns in architecture-patterns.md.

Integration Decision Tree

START
│
├─ Do you need on-chain verification on Ethereum/Base/etc?
│   ├─ YES → Use zkverify-attestation pattern
│   │         (proofs aggregated, attested to L1)
│   └─ NO → Use zkverify-direct pattern
│            (verify directly on zkVerify chain)
│
├─ Which integration method?
│   ├─ Simplest (REST API) → zkverify-kurier
│   ├─ Full control (JS/TS) → zkverify-sdk
│   └─ Low-level/custom → zkverify-rpc
│
└─ Which proof system? (See selection guide above)

Getting Started Checklist

1. Define your use case

   • What computation needs to be proven?
   • What should remain private?
   • Where does verification need to happen?

2. Choose proof system

   • Match to your use case using selection guide
   • Consider: circuit complexity, proving time, verification cost

3. Design architecture

   • Direct vs cross-chain attestation
   • Integration method (Kurier/SDK/RPC)

4. Implementation

   • Use corresponding builder skill (zkverify-groth16, zk-noir-builder, etc.)
   • Use integration skill (zkverify-sdk, zkverify-kurier, zkverify-rpc)
   • If cross-chain: use zkverify-contracts for L1 verification

Related Skills

• Proof Builders: zkverify-groth16, zk-noir-builder, zk-risczero-builder, zk-sp1-builder, zk-plonky2-builder, zk-ezkl-builder, zk-fflonk-builder
• Integration: zkverify-sdk, zkverify-kurier, zkverify-rpc
• Scenarios: zkverify-direct, zkverify-attestation
• Contracts: zkverify-contracts

Web Search Triggers

When users ask about:

• Latest ZK proof systems or versions
• New zkVerify features or supported proofs
• ZK ecosystem developments (new zkVMs, tools)
• Specific project integrations

Use web search to get current information, as the ZK ecosystem evolves rapidly.