Production ZK · Post-Quantum Safe

2.0µs prove. 2.09ns verify.
STARK verification, SHA3-256 hash, FRI commitments.

Q: What is a STARK proof?

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.

Q: How is H33's ZKP different from Groth16 or PLONK?

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.

Q: What does "4-layer AIR" mean?

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.

Q: Why is cached lookup faster than proof generation?

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 44x faster with zero network overhead.

Q: Can ZKP proofs be verified by third parties?

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.

Q: How does ZKP integrate with FHE?

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.

Q: What is the proof size?

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.

Q: Is ZKP verification constant-time?

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.

Q: Can I use H33 ZKP without FHE?

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.

Q: How does caching affect security?

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.

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

Get API Key Read the Docs

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.

LOOKUP

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.

~180 KB

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.

POST-QUANTUM

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

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

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

4-Layer AIR Constraints

Algebraic Intermediate Representation with 7-column constraint system. Biometric-specific verification predicates baked into the proof structure.

SHA3-256

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 SETUP

No Trusted Setup

Unlike SNARKs (Groth16, PLONK), STARKs require zero ceremony. No “toxic waste” to manage. Security derives entirely from hash collision resistance.

FRI

FRI Commitment Scheme

Fast Reed-Solomon Interactive Oracle Proof. Logarithmic proof size. Efficient verification even for complex constraint systems.

Advanced STARK Engineering

Three primitives most ZK systems don't ship.

Production audit trail infrastructure built on top of the core STARK engine. Post-quantum. Pure Rust. SHA3-256 only.

Epoch-Evolved Nullifiers

Unlinkable Proof IDs

Proof identifiers rotate per time window without changing the underlying key. Same vendor, same codebase, different epoch — completely different nullifier. Observers cannot correlate proof submissions across sessions.

η_e ← SHA3-256(k ‖ ρ ‖ epoch)
6 modes: hourly, daily, weekly, monthly, per-session, custom
Constant-time verification (timing-attack resistant)

Proof Re-Randomization

Client-Side Proof Blinding

The client blinds the STARK proof after receiving it. Same logical guarantee, different bytes. The server that generated the proof cannot fingerprint the submission. AES-256-GCM commitment wrapper.

blinded = AES-GCM(KDF(r), proof)
Structural verification without decryption
Replay detection via proof hash

Recursive Accumulation

One Proof Covers Thousands

Fold N event proofs into a single constant-size accumulator. After 10,000 events, the verifier checks one 32-byte hash. O(1) verification. Merkle inclusion proofs for individual events.

acc = SHA3-256(acc_old ‖ event ‖ data)
Chain-hashed sequential ordering
Logarithmic individual event proof

Read the technical deep dive →

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.