Production ZK · Post-Quantum Safe
2.0µs prove. 2.09ns verify.
STARK verification, SHA3-256 hash, FRI commitments.
H33 ZKP Stark Lookup is H33's production zero-knowledge proof system. Prove any statement about private data — age, identity, credit, location — without revealing the data itself. ~180KB proofs. Post-quantum safe. One API call.
2.0µs
Prove (async)
2.09ns
Verify (cached)
~180KB
Proof Size
56-bit Q
SHA3-256 Hash
What is H33 ZKP Stark Lookup
Prove facts without revealing secrets.
H33 ZKP Stark Lookup lets your application prove that a computation was performed correctly — without revealing the underlying data. STARK verification with SHA3-256 hashing and FRI commitments. This is the cryptographic primitive behind private identity verification.
Table-based proofs
Traditional ZK systems re-execute computations inside a circuit. H33 ZKP Stark Lookup takes a different approach: it proves computational integrity using STARK verification with SHA3-256 hashing and FRI commitments. This makes proofs about membership, range checks, and set containment extraordinarily fast and post-quantum secure.
Transparent, post-quantum proofs
A complete H33 ZKP Stark Lookup proof is ~180KB. No trusted setup required. Based on hash functions (SHA3-256), not elliptic curves, making them inherently quantum-resistant. Proof caching achieves 2.09ns verification for returning users.
Quantum-safe by construction
H33 ZKP Stark Lookup is built on hash-based commitments (SHA3-256) and algebraic structures that resist quantum attacks. When combined with H33's Dilithium signatures and Kyber key encapsulation, you get an end-to-end post-quantum proof pipeline. No classical elliptic curve assumptions. No trusted setup ceremony. Ready for the post-quantum era today.
Raw Performance
Microseconds, not milliseconds.
Benchmarked with Criterion.rs, 100+ samples. These numbers are measured, not projected.
Prove
2.0µs
Generate a complete H33 ZKP Stark Lookup proof (async)
Verify (cached)
2.09ns
Cached verification for returning users
Proof Size
~180KB
Transparent, no trusted setup
Comparison
Orders of magnitude apart.
H33 ZKP Stark Lookup vs every major ZK proof system in production. Same security guarantees, different universe of performance.
Note: Competitor timings below are legacy/pre-optimization baselines. See API docs for current H33 KZG & IPA production numbers (e.g., KZG prove 40.7ms, IPA prove 40.6ms after Rayon parallelization).
| System | Prove (Legacy) | Verify (Legacy) | Proof Size | Trusted Setup | vs H33 (Prove) | vs H33 (Verify) |
|---|---|---|---|---|---|---|
| H33 ZKP Stark Lookup | 2.0µs (async) | 2.09ns (cached) | ~180KB | None | — | — |
| Groth16 | 18ms | 2.14ms | 96B | Required | 10,588x slower | 13,129x slower |
| KZG | 108ms | ~5ms | 96B | Required | 63,529x slower | 30,675x slower |
| IPA (Bulletproofs) | 170ms | ~12ms | 944B | None | 100,000x slower | 73,620x slower |
| FRI (STARK) | 30ms | ~3ms | 47KB | None | 17,647x slower | 18,405x slower |
| RISC Zero (zkVM) | 44+ sec | ~250ms | ~200KB | None | 25,882,353x slower | 1,533,742x slower |
Inside H33 Auth
<1% of the pipeline. 100% of the proof.
H33 ZKP Stark Lookup runs as part of H33's 1.36ms CollectiveAuthority flow. It generates the zero-knowledge proof that confirms identity without any data exposure.
Step 1
BFV Encrypt
385µs (27%)
Step 2
FHE Inner Product
650µs (45%)
Step 3
Threshold Decrypt
268µs (19%)
Step 4
Combine+SHA3
75µs (5%)
Step 5
Dilithium Batch Attest
42µs (4%)
Total H33 CollectiveAuthority: 1,280µs · H33 ZKP Stark Lookup is the ZK layer that makes zero data exposure possible.
Core Features
What makes H33 ZKP different.
Six engineering decisions that separate H33 STARK proofs from every other ZK system in production.
2.0µs First Proof
Full STARK proof generation in 2 microseconds. SHA3-256 hash-based, no trusted setup. Post-quantum secure by construction.
0.062µs Cached Lookups
DashMap in-process cache delivers subsequent lookups in 62 nanoseconds. 44× faster than raw STARK generation. Zero network hops.
4-Layer AIR Constraints
Algebraic Intermediate Representation with 7-column constraint system. Biometric-specific verification predicates baked into the proof structure.
SHA3-256 Hash Foundation
NIST-standard hash function provides 128-bit collision resistance. No elliptic curve assumptions. Quantum computers cannot accelerate hash collision search.
No Trusted Setup
Unlike SNARKs (Groth16, PLONK), STARKs require zero ceremony. No “toxic waste” to manage. Security derives entirely from hash collision resistance.
FRI Commitment Scheme
Fast Reed-Solomon Interactive Oracle Proof. Logarithmic proof size. Efficient verification even for complex constraint systems.
What You Can Prove
Private proofs for real applications.
Every proof confirms a fact about the user without revealing the underlying data. The verifier learns the answer — never the secret.
Identity
Age Verification
Prove a user is over 18, 21, or 65 without revealing their birthdate. The verifier learns “yes/no” — nothing else.
Prove: 2.0µs (async) · Statement: age ≥ threshold
Finance
Credit Worthiness
Prove a credit score exceeds a minimum threshold without revealing the actual score. No data leaves the user's control.
Prove: 2.0µs (async) · Statement: score ≥ 650
Compliance
Residency & Jurisdiction
Prove a user resides in an eligible jurisdiction without revealing their address. Coordinate-level precision, zero location exposure.
Prove: 2.0µs (async) · Statement: location ∈ region
Identity
Biometric Match
Prove a biometric template matches a stored reference using SHA3-256 hash and cosine similarity — entirely in ZK. Template never leaves encrypted form.
Prove: 2.0µs (async) · Statement: similarity ≥ 0.95
Healthcare
Medical Eligibility
Prove insurance status, treatment eligibility, or patient identity for HIPAA-compliant workflows. No PHI exposed to the verifier.
Prove: 2.0µs (async) · Statement: eligible = true
Finance
KYC / AML Compliance
Prove KYC completion and sanctions clearance without passing personal data between institutions. The proof is reusable across verifiers.
Prove: 2.0µs (async) · Statement: kyc_passed ∧ ¬sanctioned
Integration
Three lines to prove. One to verify.
zk-stark-example.js
JavaScript
// Generate a zero-knowledge age proof const proof = await h33.zkp.prove({ 'statement': 'age_gte', 'threshold': 21, 'private_input': user.birthdate, // never leaves client 'public_input': Date.now() }); // proof.size = ~180KB | proof.time = 2.0µs (async) // Verify on server — no private data needed const valid = await h33.zkp.verify(proof); // valid = true | verify.time = 2.09ns (cached) // Batch verify 64 proofs at once const results = await h33.zkp.batchVerify(proofs); // 64 proofs verified, 2.09ns each (cached) // Or use it inside full-stack auth (1.36ms total) const auth = await h33.auth.verify({ userId: 'user_123', biometric: faceData, // H33 ZKP Stark Lookup proof generated automatically as part of the flow });
FAQ
Frequently asked questions.
Technical answers to the most common questions about H33's zero-knowledge proof system.
A Scalable Transparent ARgument of Knowledge. A cryptographic proof that a computation was performed correctly, without revealing the inputs. "Transparent" means no trusted setup — security derives entirely from public hash functions, not secret ceremony parameters.
Groth16 and PLONK are SNARKs that rely on elliptic curve pairings — which are vulnerable to quantum attack. H33 uses STARKs with SHA3-256, making proofs quantum-safe by construction. No trusted setup ceremony is required, eliminating the risk of compromised "toxic waste" parameters.
AIR stands for Algebraic Intermediate Representation. H33's constraint system has 4 layers: input validation, biometric predicate, threshold check, and output commitment. The system uses 7 columns total to express these constraints efficiently within the STARK proof framework.
The first proof runs the full STARK prover (
~2.0µs). The result is cached in an in-process DashMap. Subsequent identical lookups return the cached proof in ~0.062µs — a hash table lookup, not a new proof generation. That's 44× faster with zero network overhead.Yes. The proof, public inputs, and verification key are all that's needed. Any party can verify the proof without access to the prover's private inputs. This is a fundamental property of zero-knowledge proofs — verification is decoupled from the secret data.
ZKP proves that the FHE computation was performed correctly on the encrypted data. The full pipeline is: FHE encrypt → FHE compute (inner product) → ZKP prove (STARK lookup) → Dilithium attest (post-quantum signature). Each layer reinforces the others.
H33 STARK proofs are
~45KB (logarithmic in computation size). Verification takes ~0.2µs. Compact enough for on-chain attestation when needed, while maintaining full transparency and quantum resistance.Yes. Verification time is independent of the computation complexity. The verifier checks the FRI commitment and AIR constraints in fixed time. This prevents timing side-channels and ensures predictable latency regardless of proof content.
The ZKP layer is part of the integrated H33 pipeline. It verifies FHE computation correctness as a core step in the authentication flow. Standalone ZKP is not exposed as a separate API endpoint — the three layers (FHE, ZKP, PQC signatures) are designed to work together.
Cached proofs are the same proofs generated by the STARK prover. Caching is a performance optimization, not a security tradeoff. The proof's cryptographic validity is independent of how it was retrieved — whether freshly generated or served from the DashMap cache.
Prove anything. Reveal nothing.
1,000 free auths. ZK proofs included in every tier. No license fees.