ZK protocol family

ZKCZero-Knowledge Compliance

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 request

The 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-Core
  • Jurisdiction

    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-Standard
  • Accreditation

    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-Standard
  • Source 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-Standard
  • Tax 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-Full
  • Sanctions 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-Full
  • Attribute Set

    Selectively disclose fixed-position attributes while proving every revealed value came from issuer-authoritative state.

    Reference Profile

Protocol Stack

LAYER 01 Proof Types KYC Jurisdiction Accreditation Tax Source of Funds … LAYER 02 Attestation Layer Credential Format Issuance Revocation Registry LAYER 03 Client SDK Proof Generation Key Management Credential Store LAYER 04 Verifier Spec Proof Formats Verification Trust Policies

Getting Started

  • Read the Spec

    Understand credential types, proof circuits, attestation layer, and verifier integration.

    View Specification
  • Agent Integration

    LLM-optimized documentation for autonomous agent consumption and automated compliance.

    View llms.txt
  • ZKA 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