ZKC · Open specification
Zero-Knowledge Compliance
User-controlled compliance for privacy-preserving systems
ZKC enables users to generate cryptographic proofs satisfying regulatory requirements without revealing underlying private data. Compliance becomes a capability controlled by the user, not an enforcement mechanism controlled by the protocol. Zero-knowledge proofs, authenticated proof requests, holder-custodied disclosure receipts, privacy-preserving revocation, and verifier-controlled trust policies.
Design Principles
User Sovereignty
Users control when, what, and to whom they disclose. Compliance is an optional capability, not a mandatory constraint enforced by the protocol.
Protocol Neutrality
No compliance logic in the base protocol. ZKC is a separate layer that integrates with privacy-preserving payment systems without compromising their design.
Verifier Flexibility
Verifiers decide what proofs they accept and which issuers they trust. No central authority dictates compliance requirements.
Portability
Works across multiple chains and payment systems. Designed to integrate with ZKA, Namada, Penumbra, Ethereum L2s, and any privacy-preserving settlement layer.
Privacy Preservation
Proofs reveal the minimum necessary information. Anonymous presentation is the default; scoped continuity and globally linkable presentation require progressively more explicit consent.
Verifier Accountability
Verifiers sign every disclosure request, and a conforming SDK refuses unsigned requests by default. The holder keeps a self-contained receipt recording what was requested, for which purpose, and whether it was answered.
Open Predicates
No credential, predicate, or issuer is privileged. Predicate circuits are inspectable and versioned, and conforming SDKs refuse opaque predicates by default.
Protocol Composition
ZKC establishes eligibility, ZKM authorization establishes permission to act, and ZKA settlement establishes whether the value transition settles. Each remains independently verified.
Compliance as Capability
ZKC inverts the traditional compliance model:
| Traditional Model | ZKC Model |
|---|---|
| Protocol enforces compliance | User generates compliance proofs |
| Counterparty demands access | User chooses what to disclose |
| Compliance is mandatory | Compliance is optional capability |
| Protocol knows identity | Protocol is identity-blind |
| Regulators access protocol | Regulators verify user proofs |
Compliance Proof Example
Illustrative pseudocode: users generate ZK proofs to satisfy verifier requirements without revealing private data. The normative interfaces are defined in the specification; this example follows its exchange integration pattern (§6.3).
// User wants to deposit to a compliant exchange
// Exchange requires: KYC + sanctions clearance, from the same holder
// 1. User already holds credentials from trusted issuers
const credentials = client.listCredentials({
types: ["zkc:cred:kyc:v1", "zkc:cred:sanctions:v2"],
notExpired: true
});
// 2. Exchange signs an Authenticated Proof Request (APR) and keeps it.
// Two proof types about one holder form a conjunction, so the request
// uses the scoped profile with the "session" scope policy. The default
// zkc:presentation:anonymous:v1 profile cannot answer it: the holder
// refuses (ANONYMOUS_COMPOSITE_REFUSED) and a verifier rejects an
// anonymous answer (UNBOUND_COMPOSITE).
const purpose = "exchange deposit eligibility";
const purposeTag = H("zkc/purpose", canonicalPurpose(purpose));
const contextProfile = "zkc:context:purpose-bound:v1";
const request = {
requirements: {
proofTypes: ["zkc:proof:kyc:v2", "zkc:proof:sanctions:v8"],
parameters: { // closed key set per proof type
"zkc:proof:kyc:v2": {
requiredLevel: 2,
requiredAttributes: [true, false, false, false, false]
},
"zkc:proof:sanctions:v8": {
canonicalSet: blockedScreeningCodes,
setRoot: blockedScreeningRoot
}
},
// reference age without the signed verification-context extension
maxProofAge: 3600,
context: {
profile: contextProfile,
value: H("zkc/context", contextProfile, exchange.id, sessionId,
purposeTag, timestamp),
verifierId: exchange.id,
sessionId, // fresh for every request
timestamp,
purpose,
purposeTag
}
},
trustPolicy: exchange.trustPolicy,
presentation: {
profile: "zkc:presentation:scoped:v1",
scopePolicy: "session",
rotationEpochSeconds: 0
}
};
const apr = signAPR(request, exchange.verifierKey);
// kept in the exchange's own session state
exchange.pending.set(depositSession, apr);
// 3. The holder SDK validates the APR signature, expiry, nonce, and
// purpose-bound context, then records separate consent for each atomic
// predicate before calling the canonical generation interface.
const proof = await client.generateProof(apr.request, credentials);
// Proves: KYC level >= 2 with the requested attribute flag set; screening
// code not in the blocked-code set; both credentials in their issuers'
// recorded non-revocation accumulators
// Hides: name, address, date of birth, credential IDs, screening code
// Reveals: each issuer's public key, accumulator root and epoch, and one
// pseudonym shared by both proofs; a fresh request context gets a new one
// 4. The verifier validates the same signed APR it retained, never a copy
// carried with the proof
async function checkDeposit(depositSession, proof) {
const expected = exchange.pending.get(depositSession);
if (expected === undefined) return false;
const result = await exchange.verifier
.verifyAuthenticated(expected, proof, expected.request);
if (result.valid) exchange.pending.delete(depositSession);
return result.valid;
}
// 5. The holder retains a Disclosure Receipt for the signed requestThe exchange learns that one holder meets both requirements, which issuer keys signed the credentials, and a pseudonym that does not recur in a fresh request context. No name, address, or date of birth crosses the wire.
Credential Types
ZKC publishes non-exclusive, well-known reference credential types for interoperability. Verifiers may accept other open credential and predicate definitions. Each card states what the current proof identity proves. What an issuer checks before it signs a credential is the issuer's responsibility, and whether to rely on it is the verifier's trust-policy choice.
KYC
Prove that an issuer-signed verification level is at least the requested level and that the requested verified-attribute flags are set, without revealing personal data.
ZKC-CoreJurisdiction
Prove that an issuer-signed jurisdiction of the requested claim type (residency, citizenship, or tax residency) is in an allowed set, or outside a canonically constructed blocked set.
ZKC-StandardAccreditation
Prove that an issuer-signed accreditation level is at least the requested level and, when requested, the issuer-signed institutional flag. It does not prove a jurisdiction.
ZKC-StandardSource of Funds
Prove that an issuer-signed source code is in the verifier's accepted-source set. It proves no amount and no verification level; how the source was verified rests with the issuer.
ZKC-StandardTax Compliance
Prove that an issuer-signed tax jurisdiction is in the verifier's accepted set and that the tax year is at least a requested minimum. It does not prove that obligations were filed or paid.
ZKC-FullSanctions Clearance
Prove that an issuer-signed screening code is not in the verifier's canonical blocked-code set. It does not prove which lists (OFAC, UN, EU, UK) were checked, or when.
ZKC-FullAttribute Set
Selectively disclose fixed-position attributes while proving every revealed value came from issuer-authoritative state.
Reference Profile
Protocol Stack
Getting Started
Read the Spec
Understand credential types, proof circuits, attestation layer, and verifier integration.
View SpecificationAgent Integration
LLM-optimized documentation for autonomous agent consumption and automated compliance.
View llms.txtZKA Protocol
Learn how ZKC integrates with ZKA privacy-preserving payments for compliant shielded transactions.
Visit ZKA.dev
Use Cases
- Compliant DeFi Access
- Prove a minimum KYC level and a minimum accreditation level, as one holder under a scoped presentation, to access regulated DeFi protocols without revealing personal data
- Cross-Border Compliance
- Prove jurisdiction residency for regulatory requirements using set membership proofs
- Institutional On-Ramps
- Answer an exchange's deposit request for KYC, source of funds, and sanctions clearance with one scoped presentation; the exchange verifies each proof itself, because an aggregation block verifies no inner proof
- Tax Reporting
- Prove an accepted tax jurisdiction and a minimum tax year to counterparties without revealing filed amounts; whether obligations were filed or paid rests on what the issuer checked before signing
- Agent Compliance
- AI agents automatically generate and present compliance proofs based on configurable policies
- Privacy-Preserving AML
- Prove that an issuer-signed screening code is outside the verifier's blocked-code set without revealing identity to the verifier; the verifier still learns which issuer key signed the credential