Frequently Asked Questions
Common questions about ZKC, user-controlled compliance, and privacy-preserving regulatory proofs.
Why ZKC?
Why does privacy-preserving compliance matter?
Traditional compliance requires revealing personal data to every counterparty. Consider a user depositing to a DeFi protocol:
- The protocol learns their full identity (name, address, government ID)
- This data becomes a honeypot for breaches
- The user has no control over how data is stored or shared
- Every service they interact with accumulates more personal data
ZKC lets users prove they meet regulatory requirements without revealing the underlying data. The verifier learns "this user has valid KYC" but not "this user is John Smith at 123 Main St."
How is this different from just showing a credential?
Showing a credential reveals everything on it. ZKC enables selective disclosure:
- Traditional: "Here's my passport" — reveals name, DOB, nationality, photo, passport number
- ZKC: "I can prove I'm a citizen of an EU country" — reveals the proven claim and the public inputs the proof carries (such as the issuer's public key and its revocation-accumulator root and epoch), not the country, name, or passport number
Anonymous is the default: the v2 anonymous profile exposes no holder-derived public handle. A verifier may request a scoped pseudonym through a signed, purpose-bound request, while the legacy globally linkable presentation is available only as an explicitly consented linkable profile.
A request for two or more proof types about one holder is answered under the scoped profile, preferably with a per-session scope. Anonymous proofs bind to no single holder, so the holder refuses an anonymous answer to such a request and a verifier rejects one, unless the verifier declares the proofs independent facts that different holders may prove and the holder explicitly opts in.
Doesn't privacy conflict with compliance?
No. A ZKC proof answers the predicate a verifier needs over an issuer-signed credential, without revealing unnecessary data. What the issuer checked before signing is covered by the verifier's decision to trust that issuer:
A regulator needs to know "is this user KYC'd by a regulated entity?" — not "what is this user's home address?" ZKC answers the first question, through the verifier's trust policy over issuer keys, without answering the second.
When plaintext or broader disclosure is required, the same accountability rules apply: the verifier signs a purpose-bound request and the holder retains a receipt. ZKC can make a later purpose violation attributable; it cannot force a verifier to explain a silent refusal or prevent data from being re-evaluated after disclosure.
Technical Design
How do ZKC proofs work?
ZKC uses zero-knowledge proofs written in Noir and proven via UltraHonk. The flow:
- Credential issuance: A trusted issuer (e.g., KYC provider) verifies the user off-chain and issues a signed credential
- Authenticated request: A verifier signs an Authenticated Proof Request (APR) stating the predicates, trust policy, purpose, replay context, and presentation profile
- Proof generation: After separate consent for each atomic predicate, the user's client generates one ZK proof per requested predicate, showing that their credential satisfies it
- Verification: The verifier checks each proof against the signed request it retained, without seeing the credential
- Receipt: The holder retains a Disclosure Receipt for the answered or refused request
A valid proof shows that a credential signed by the issuer key it names satisfies the requested predicate and is in that issuer's recorded non-revocation accumulator. It proves only what its circuit constrains, and the verifier also learns the issuer key and the accumulator state.
What is "accumulator-based revocation"?
Credentials can be revoked (e.g., if a user fails re-verification). The challenge: how do you revoke without revealing which credential was revoked?
ZKC uses a cryptographic accumulator — a Poseidon2 Merkle tree over the identifiers of active credentials, in which a holder can prove membership without revealing which credential is being checked. When a credential is revoked, it is removed from the active set; subsequent proofs must use a fresh witness. A verifier compares each proof's accumulator root with the root the issuer published for that epoch, because an epoch check alone enforces no revocation.
Each successful issuance, revocation, or atomic renewal advances the accumulator by exactly one epoch, and nothing else does. A verifier accepts a proof whose accumulator epoch is at most 10 epochs behind its current view (MAX_EPOCH_LAG) and rejects a future epoch. An epoch is not a time period, so freshness in time is a separate check on the signed announcement time.
Current issuer state is distributed as signed revocation metadata (zkc:epoch-announcement:v3 inside zkc:issuer-metadata:v2) under a pre-pinned issuer key; selective-disclosure and authenticated-rebind proofs are accepted only against roots from that signed chain. Holders and verifiers reject stale, future, unsigned, or mismatched state, persist accepted checkpoints across restarts, and retain conflicting signed announcements as fork evidence instead of silently choosing one view. This is local fork detection, not global consistency: isolated, internally consistent histories remain undetected until their signed checkpoints are compared. Credential revocation affects only whether a counterparty accepts a proof; it never freezes or invalidates an underlying asset.
How is the verifier held accountable?
A conforming SDK refuses unauthenticated requests by default. The verifier signs an APR under a stable identity, the purpose-bound context profile binds the declared purpose into the proof context, and the holder keeps a self-contained Disclosure Receipt. Hosted provers, proxies, indexers, and SDK operators are not allowed to require custody of those receipts.
The mechanism proves that a verifier key asked for a disclosure; named-entity weight still depends on continuity between that key and the real organization. It also cannot force the verifier to issue a signed explanation when it declines a user.
What proving system does ZKC use?
ZKC circuits are written in Noir, a domain-specific language for zero-knowledge proofs. Proofs are generated using UltraHonk over the BN254 curve via Barretenberg. The protocol is proving-system-agnostic; UltraHonk is the proving system of the reference circuits.
| Property | What it means for ZKC |
|---|---|
| Noir circuit language | Inspectable, versioned circuit source, which Safeguard 4 requires for every credential and predicate circuit |
| UltraHonk over BN254 | The proving system of the reference circuits, run with Barretenberg; registry artifact bindings record the exact compiler and backend provenance |
| Simulated-recursion aggregation | An aggregation block commits to up to eight proofs with a consent flag for each. It verifies no inner proof, so the verifier still verifies each proof itself |
What does "verifier-controlled trust" mean?
There is no central authority that decides which issuers are trusted. Instead:
- Each verifier publishes a trust policy listing which issuers they accept
- Users can query the registry to find verifiers that accept their credentials
- The registry provides discovery (find issuers) but not trust (decide which issuers are good)
- A registry is advisory: registry membership is neither necessary nor sufficient for trust, and a verifier's own policy can pin issuers and predicates that appear in no registry
This mirrors how compliance works in the real world: different exchanges and institutions have different requirements and trust different KYC providers.
Credential Types
What credentials does ZKC support?
ZKC defines seven non-exclusive, well-known reference credential schemas for interoperability. They are not a closed list and no issuer or predicate is privileged. The table states what the current proof identity for each proves; what an issuer checks before it signs is a matter of the verifier's trust in that issuer:
| Credential | What It Proves | Level |
|---|---|---|
| KYC | Issuer-signed verification level is at least the requested level, and the requested verified-attribute flags are set | Core |
| Jurisdiction | Issuer-signed jurisdiction of the requested claim type (residency, citizenship, or tax residency) is in an allowed set, or outside a canonical blocked set | Standard |
| Accreditation | Issuer-signed accreditation level is at least the requested level and, when requested, the institutional flag is set; no jurisdiction is proven | Standard |
| Source of Funds | Issuer-signed source code is in the verifier's accepted-source set; no amount or verification level is proven | Standard |
| Tax Compliance | Issuer-signed tax jurisdiction is in the accepted set and the tax year is at least the requested minimum; no filing or payment status is proven | Full |
| Sanctions Clearance | Issuer-signed screening code is not in the verifier's canonical blocked-code set; no list coverage or screening date is proven | Full |
| Attribute Set | Selective disclosure of fixed-position values proven against issuer-authoritative state | Reference |
How does the jurisdiction proof work?
The jurisdiction proof uses set membership proofs. The verifier specifies either:
- Allowed list: "User must be resident of US, UK, or EU member states"
- Blocked list: "User must NOT be resident of sanctioned countries"
The proof demonstrates that the user's issuer-signed jurisdiction, for the requested claim type, is in the allowed set or not in the blocked set. Inclusion is a Merkle membership proof. Exclusion is a sorted-neighbour non-membership proof, which is sound only over a canonically constructed blocked set, so the verifier supplies the canonical code list and both sides derive the root from it. The verifier learns that the jurisdiction satisfies the requirement, not which member of an allowed set it is — unless the request fixes the inclusion path to one member instead of letting the holder derive it from a canonical code list, which discloses that member.
Can proofs be aggregated?
Yes, with explicit consent for every atomic predicate. An aggregation block commits to up to eight proof slots, with a consent flag for each active slot, under a simulated-recursion profile while backend-native recursive verification matures. It does not prove that any inner proof is valid, that the proofs belong to one holder, or that they answer the request, so the verifier verifies every individual proof itself and treats the block only as an additional commitment. Binding the proofs to one holder is the job of the presentation profile (scoped, or the explicitly consented linkable profile), not of aggregation. Aggregation does not turn a multi-predicate request into ambient or blanket consent.
Implementation
How does ZKC integrate with ZKA?
ZKC credential binding keys and ZKA value-address keys use AFP-KDC v1.0.3 current registry metadata while preserving the immutable AFP-KDC v1.0.2 32-byte master-seed profile; they derive along separate paths. This means:
- Compliance proofs can be bound to shielded transactions without revealing identity
- The credential commitment and ZKA address are unlinkable without the seed
- The credential binding key is derived from the seed, not from the spending key
ZKC is also designed to integrate with other privacy-preserving systems, such as Namada, Penumbra, and Ethereum L2s, while remaining agnostic to specific implementations.
How do ZKC, ZKM, and ZKA fit together?
The three protocols answer different questions. ZKC eligibility proves that a holder satisfies a predicate. ZKM authorization proves that a principal permitted an agent to perform a bounded action. ZKA settlement determines whether the resulting value transition is valid and settles.
A target that supports the exact statements, verification keys and presentation profile can verify the credential subject as the mandate principal at issuance or as the ZKA recipient at spend. The spend route uses direct atomic settlement. See the ZKC specification, §1.2a. ZKC owns the zkc/* namespace and ZKM owns zkm/*.
What are the conformance levels?
Implementations can target different levels of ZKC support:
- ZKC-Core: KYC proofs and basic verification
- ZKC-Standard: Core + jurisdiction, accreditation, and source of funds
- ZKC-Full: Standard + tax compliance, sanctions clearance, and proof aggregation (the highest core level)
Core, Standard, and Full form a strictly monotonic ladder, each a superset of the one below. ZKC-Agent is not a rung above Full but an orthogonal extension profile: the agent API for automated compliance, layered on any claimed core level (typically Full).
What is the Agent API?
The ZKC-Agent extension profile adds an API for autonomous agents (AI or otherwise) to handle compliance programmatically:
- Auto-respond: Automatically generate proofs for trusted verifiers after validating their authenticated requests
- Policy-based: Configure a disclosure ceiling per proof type; a proof type without a typed parameter comparison is never auto-disclosed
- Pre-computation: Generate proofs in advance for anticipated requests
- Counterparty verification: Verify the other party's compliance before transacting
This enables agent-to-agent compliance where both parties can verify each other meets requirements without human intervention.