@coordination-network/credential 0.0.1

package/dist/registry-client.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkMemberRegistryClient = void 0;
+const viem_1 = require("viem");
+const REGISTRY_ABI = [
+    {
+        type: "function",
+        name: "isApproved",
+        stateMutability: "view",
+        inputs: [{ name: "memberNetworkId", type: "bytes32" }],
+        outputs: [{ type: "bool" }]
+    }
+];
+/**
+ * Chain-backed read of NetworkMemberRegistry.isApproved (spec, network member
+ * registry). Satisfies the approval half of Resolver so it can back the
+ * issuance and verification governance gates once a registry is deployed.
+ */
+class NetworkMemberRegistryClient {
+    constructor(registryAddress, rpcUrl) {
+        this.registryAddress = registryAddress;
+        this.client = (0, viem_1.createPublicClient)({ transport: (0, viem_1.http)(rpcUrl) });
+    }
+    async isApprovedNetworkMember(id) {
+        return this.client.readContract({
+            address: this.registryAddress,
+            abi: REGISTRY_ABI,
+            functionName: "isApproved",
+            args: [id]
+        });
+    }
+}
+exports.NetworkMemberRegistryClient = NetworkMemberRegistryClient;

package/dist/resolver.d.ts

@@ -0,0 +1,37 @@
+import { Hex32, Jwk } from "./types";
+/**
+ * Pluggable resolution of urn:cn: identifiers to registry state (spec 07,
+ * trust model). In-memory for now; registry contracts back a chain
+ * implementation later.
+ */
+export interface Resolver {
+    isApprovedNetworkMember(id: Hex32): Promise<boolean>;
+    getCredentialPublicKey(id: Hex32): Promise<Jwk | null>;
+    isRevoked(commitment: bigint): Promise<boolean>;
+}
+/** The approval half of Resolver — all issuance needs, and all the chain-backed registry client provides. */
+export type ApprovalResolver = Pick<Resolver, "isApprovedNetworkMember">;
+/**
+ * Write side of the revocation registry. Separate from Resolver because
+ * verifiers never hold it.
+ */
+export interface RevocationWriter {
+    revoke(commitment: bigint): Promise<void>;
+}
+/**
+ * In-memory registry state for tests and the demo issuer service. The seed
+ * methods stand in for the one-time on-chain writes (member admission, key
+ * publication); the async interface methods mirror the chain reads.
+ */
+export declare class InMemoryResolver implements Resolver, RevocationWriter {
+    private readonly approved;
+    private readonly credentialKeys;
+    private readonly revoked;
+    approveMember(id: Hex32): void;
+    removeMember(id: Hex32): void;
+    setCredentialPublicKey(id: Hex32, jwk: Jwk): void;
+    isApprovedNetworkMember(id: Hex32): Promise<boolean>;
+    getCredentialPublicKey(id: Hex32): Promise<Jwk | null>;
+    isRevoked(commitment: bigint): Promise<boolean>;
+    revoke(commitment: bigint): Promise<void>;
+}

package/dist/resolver.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryResolver = void 0;
+/**
+ * In-memory registry state for tests and the demo issuer service. The seed
+ * methods stand in for the one-time on-chain writes (member admission, key
+ * publication); the async interface methods mirror the chain reads.
+ */
+class InMemoryResolver {
+    constructor() {
+        this.approved = new Set();
+        this.credentialKeys = new Map();
+        this.revoked = new Set();
+    }
+    approveMember(id) {
+        this.approved.add(id);
+    }
+    removeMember(id) {
+        this.approved.delete(id);
+    }
+    setCredentialPublicKey(id, jwk) {
+        this.credentialKeys.set(id, jwk);
+    }
+    async isApprovedNetworkMember(id) {
+        return this.approved.has(id);
+    }
+    async getCredentialPublicKey(id) {
+        return this.credentialKeys.get(id) ?? null;
+    }
+    async isRevoked(commitment) {
+        return this.revoked.has(commitment.toString());
+    }
+    async revoke(commitment) {
+        this.revoked.add(commitment.toString());
+    }
+}
+exports.InMemoryResolver = InMemoryResolver;

package/dist/revocation.d.ts

@@ -0,0 +1,25 @@
+import { EddsaPublicKey, EddsaSignature, StatusClaim } from "./types";
+/** Generates a fresh 32-byte revocation secret r. Device-side only. */
+export declare function generateRevocationSecret(): Uint8Array;
+/** commitment = new Identity(r).commitment (Semaphore V4). */
+export declare function deriveRevocationCommitment(r: Uint8Array): bigint;
+/**
+ * Signs the issuer's challenge nonce with the Baby Jubjub EdDSA key behind
+ * r, proving the device owns the commitment it asks the issuer to embed.
+ */
+export declare function signCommitmentOwnership(r: Uint8Array, nonce: Uint8Array): {
+    publicKey: EddsaPublicKey;
+    signature: EddsaSignature;
+};
+/**
+ * Issuer-side check: verifies the EdDSA signature over the nonce, recomputes
+ * the commitment from the public key, and compares it to the claimed one.
+ */
+export declare function verifyCommitmentOwnership(params: {
+    commitment: bigint;
+    publicKey: EddsaPublicKey;
+    signature: EddsaSignature;
+    nonce: Uint8Array;
+}): boolean;
+/** Builds the status.cn_zk_revocation claim for the signed body (spec 07). */
+export declare function buildStatusClaim(commitment: bigint, revocationRegistry: string): StatusClaim;

package/dist/revocation.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRevocationSecret = generateRevocationSecret;
+exports.deriveRevocationCommitment = deriveRevocationCommitment;
+exports.signCommitmentOwnership = signCommitmentOwnership;
+exports.verifyCommitmentOwnership = verifyCommitmentOwnership;
+exports.buildStatusClaim = buildStatusClaim;
+const identity_1 = require("@semaphore-protocol/identity");
+const utils_1 = require("@noble/hashes/utils");
+/**
+ * Device-side revocation material (spec 08). r is 32 random bytes, generated
+ * on the device, never leaving it. Everything below takes r as Uint8Array,
+ * never as a hex string: the two encodings derive different commitments
+ * (Semaphore hashes the raw input), and the regression test holds that line.
+ */
+function assertSecret(r) {
+    if (r.length !== 32) {
+        throw new Error("revocation secret must be 32 bytes");
+    }
+}
+function nonceToBigint(nonce) {
+    if (nonce.length === 0) {
+        throw new Error("nonce must not be empty");
+    }
+    return BigInt(`0x${(0, utils_1.bytesToHex)(nonce)}`);
+}
+/** Generates a fresh 32-byte revocation secret r. Device-side only. */
+function generateRevocationSecret() {
+    return (0, utils_1.randomBytes)(32);
+}
+/** commitment = new Identity(r).commitment (Semaphore V4). */
+function deriveRevocationCommitment(r) {
+    assertSecret(r);
+    return new identity_1.Identity(r).commitment;
+}
+/**
+ * Signs the issuer's challenge nonce with the Baby Jubjub EdDSA key behind
+ * r, proving the device owns the commitment it asks the issuer to embed.
+ */
+function signCommitmentOwnership(r, nonce) {
+    assertSecret(r);
+    const identity = new identity_1.Identity(r);
+    const signature = identity.signMessage(nonceToBigint(nonce));
+    return {
+        publicKey: [identity.publicKey[0], identity.publicKey[1]],
+        signature: { R8: [signature.R8[0], signature.R8[1]], S: signature.S }
+    };
+}
+/**
+ * Issuer-side check: verifies the EdDSA signature over the nonce, recomputes
+ * the commitment from the public key, and compares it to the claimed one.
+ */
+function verifyCommitmentOwnership(params) {
+    try {
+        if (!identity_1.Identity.verifySignature(nonceToBigint(params.nonce), params.signature, params.publicKey)) {
+            return false;
+        }
+        return identity_1.Identity.generateCommitment(params.publicKey) === params.commitment;
+    }
+    catch {
+        return false;
+    }
+}
+/** Builds the status.cn_zk_revocation claim for the signed body (spec 07). */
+function buildStatusClaim(commitment, revocationRegistry) {
+    return {
+        cn_zk_revocation: {
+            revocationRegistry,
+            revocationCommitment: commitment.toString(10)
+        }
+    };
+}

package/dist/signer.d.ts

@@ -0,0 +1,19 @@
+import { Jwk } from "./types";
+/**
+ * Issuer signing key, KMS-shaped. sign receives the JWS signing input in
+ * message mode (the service applies SHA-256 itself, never a precomputed
+ * digest) and returns the raw 64-byte r||s signature.
+ */
+export interface Signer {
+    getPublicKeyJwk(): Promise<Jwk>;
+    sign(message: Uint8Array): Promise<Uint8Array>;
+}
+/**
+ * Holder P-256 device key: the secure element in the app, a software key in
+ * tests. Same contract as Signer; a separate type because the two keys must
+ * never be interchangeable in signatures.
+ */
+export interface DeviceSigner extends Signer {
+    /** Signs an already-computed 32-byte digest, without hashing it again. */
+    signDigest(digest: Uint8Array): Promise<Uint8Array>;
+}

package/dist/signer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types.d.ts

@@ -0,0 +1,111 @@
+/** Credential and issuance types. */
+/** A 32-byte value as a 0x-prefixed hex string (e.g. a networkId). */
+export type Hex32 = `0x${string}`;
+/** An EC public key in JWK form (RFC 7517). This profile uses P-256 only. */
+export interface Jwk {
+    kty: "EC";
+    crv: "P-256";
+    x: string;
+    y: string;
+}
+export interface ApprovalScope {
+    /** Programme the approval covers. */
+    programme: string;
+    /** ISO 3166-1 alpha-3 country code. */
+    country: string;
+}
+/** Baby Jubjub EdDSA public key, shaped as Semaphore V4 exposes it. */
+export type EddsaPublicKey = [bigint, bigint];
+/** Baby Jubjub EdDSA signature, shaped as Semaphore V4 exposes it. */
+export interface EddsaSignature {
+    R8: [bigint, bigint];
+    S: bigint;
+}
+/**
+ * The custom status member inside the signed body (spec 07). The commitment
+ * is issuer-attested and visible to WS1 verifiers by design.
+ */
+export interface StatusClaim {
+    cn_zk_revocation: {
+        /** urn:cn:contract: URN of the on-chain revocation registry. */
+        revocationRegistry: string;
+        revocationCommitment: string;
+    };
+}
+/** The reconstructed claim set of a verified credential. */
+export interface ApprovalCredentialClaims {
+    vct: string;
+    iss: string;
+    sub: string;
+    jti: string;
+    nbf: number;
+    exp: number;
+    cnf: {
+        jwk: Jwk;
+    };
+    status: StatusClaim;
+    approvalScope: ApprovalScope;
+}
+export interface IssuanceRequest {
+    issuerNetworkId: Hex32;
+    subjectNetworkId: Hex32;
+    approvalScope: ApprovalScope;
+    validFrom: number;
+    validUntil: number;
+    confirmationKey: Jwk;
+    accountPublicKey: Uint8Array;
+    nonce: Uint8Array;
+    devicePopSignature: Uint8Array;
+    accountPopSignature: Uint8Array;
+    revocation: {
+        commitment: bigint;
+        publicKey: EddsaPublicKey;
+        ownershipSignature: EddsaSignature;
+    };
+}
+export interface SdJwtIssueParams extends IssuanceRequest {
+    revocationRegistry: string;
+}
+export interface ZkCredentialIssueParams extends IssuanceRequest {
+    identityPublicKey: EddsaPublicKey;
+}
+export interface ZkCredentialBody {
+    programmeHash: bigint;
+    countryCode: number;
+    notBefore: number;
+    expiresAt: number;
+    deviceKeyCommitment: bigint;
+    holderKeyCommitment: bigint;
+    revocationCommitment: bigint;
+}
+export interface ZkCredential {
+    body: ZkCredentialBody;
+    issuerPublicKey: EddsaPublicKey;
+    signature: EddsaSignature;
+}
+export interface SerializedZkCredential {
+    body: {
+        programmeHash: string;
+        countryCode: number;
+        notBefore: number;
+        expiresAt: number;
+        deviceKeyCommitment: string;
+        holderKeyCommitment: string;
+        revocationCommitment: string;
+    };
+    issuerPublicKey: [string, string];
+    signature: {
+        R8: [string, string];
+        S: string;
+    };
+}
+export type VerifyErrorCode = "MALFORMED" | "ISSUER_NOT_APPROVED" | "KEY_NOT_FOUND" | "PROOF_INVALID" | "EXPIRED" | "NOT_YET_VALID" | "REVOKED";
+/** Checks run in spec order (07, verification flow) and the first failure wins. */
+export type VerifyResult = {
+    ok: true;
+    claims: ApprovalCredentialClaims;
+} | {
+    ok: false;
+    code: VerifyErrorCode;
+    message: string;
+};

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+/** Credential and issuance types. */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/verify.d.ts

@@ -0,0 +1,29 @@
+import { Resolver } from "./resolver";
+import { Hex32, Jwk, VerifyResult } from "./types";
+export interface VerifyOptions {
+    /** Verification time, unix seconds. Defaults to now. */
+    currentDate?: number;
+}
+/**
+ * The shared verification pipeline (spec 07, verification flow), check order
+ * first-failure-wins: decode/structure -> issuer approved -> key fetch ->
+ * signature and disclosure digests -> claims shape -> validity window ->
+ * revocation. A disclosure whose digest matches nothing is silently dropped
+ * by the library (phase 1 spike), so it surfaces in the claims-shape step as
+ * a missing approvalScope member and fails MALFORMED.
+ *
+ * The library's own nbf/exp check runs against a clamped timestamp so the
+ * window verdict (EXPIRED vs NOT_YET_VALID) always comes from our check,
+ * after the signature has been verified.
+ */
+declare function runPipeline(token: string, resolver: Resolver, now: number, verifyWithLibrary: (issuerJwk: Jwk, clampedNow: number) => Promise<Record<string, unknown>>): Promise<{
+    result: VerifyResult;
+    issuerId?: Hex32;
+}>;
+/**
+ * Verifies a compact SD-JWT credential with all its disclosures — the
+ * holder's verify-on-receipt and any check that does not involve a live
+ * presentation. Key binding is not checked here; that is verifyPresentation.
+ */
+export declare function verifySdJwtCredential(token: string, resolver: Resolver, options?: VerifyOptions): Promise<VerifyResult>;
+export { runPipeline };

package/dist/verify.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifySdJwtCredential = verifySdJwtCredential;
+exports.runPipeline = runPipeline;
+const sd_jwt_vc_1 = require("@sd-jwt/sd-jwt-vc");
+const crypto_1 = require("./crypto");
+const profile_1 = require("./profile");
+const fail = (code, message) => ({ ok: false, code, message });
+/**
+ * The shared verification pipeline (spec 07, verification flow), check order
+ * first-failure-wins: decode/structure -> issuer approved -> key fetch ->
+ * signature and disclosure digests -> claims shape -> validity window ->
+ * revocation. A disclosure whose digest matches nothing is silently dropped
+ * by the library (phase 1 spike), so it surfaces in the claims-shape step as
+ * a missing approvalScope member and fails MALFORMED.
+ *
+ * The library's own nbf/exp check runs against a clamped timestamp so the
+ * window verdict (EXPIRED vs NOT_YET_VALID) always comes from our check,
+ * after the signature has been verified.
+ */
+async function runPipeline(token, resolver, now, verifyWithLibrary) {
+    let payload;
+    try {
+        const jwt = token.split("~")[0];
+        const segments = jwt.split(".");
+        if (segments.length !== 3) {
+            return { result: fail("MALFORMED", "not a compact SD-JWT") };
+        }
+        payload = JSON.parse(new TextDecoder().decode((0, crypto_1.base64urlToBytes)(segments[1])));
+        if (typeof payload !== "object" || payload === null) {
+            return { result: fail("MALFORMED", "JWS payload is not an object") };
+        }
+    }
+    catch {
+        return { result: fail("MALFORMED", "token could not be decoded") };
+    }
+    const issuerId = typeof payload.iss === "string" ? (0, profile_1.urnToNetworkId)(payload.iss) : null;
+    if (issuerId === null) {
+        return { result: fail("MALFORMED", "iss missing or not a urn:cn:network URN") };
+    }
+    if (!(await resolver.isApprovedNetworkMember(issuerId))) {
+        return {
+            result: fail("ISSUER_NOT_APPROVED", `issuer ${payload.iss} is not an approved network member`),
+            issuerId
+        };
+    }
+    const issuerJwk = await resolver.getCredentialPublicKey(issuerId);
+    if (issuerJwk === null) {
+        return { result: fail("KEY_NOT_FOUND", `no credential public key published for ${payload.iss}`), issuerId };
+    }
+    // Clamp the library's clock inside the token's window; our own check below decides the verdict.
+    let clampedNow = now;
+    if (typeof payload.exp === "number" && clampedNow > payload.exp)
+        clampedNow = payload.exp;
+    if (typeof payload.nbf === "number" && clampedNow < payload.nbf)
+        clampedNow = payload.nbf;
+    let reconstructed;
+    try {
+        reconstructed = await verifyWithLibrary(issuerJwk, clampedNow);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes("not yet valid"))
+            return { result: fail("NOT_YET_VALID", message), issuerId };
+        if (message.includes("expired"))
+            return { result: fail("EXPIRED", message), issuerId };
+        return { result: fail("PROOF_INVALID", message), issuerId };
+    }
+    const checked = (0, profile_1.validateClaims)(reconstructed);
+    if (!checked.ok) {
+        return { result: fail("MALFORMED", checked.message), issuerId };
+    }
+    const claims = checked.claims;
+    if (now < claims.nbf) {
+        return { result: fail("NOT_YET_VALID", "credential is not yet within its validity window"), issuerId };
+    }
+    if (now > claims.exp) {
+        return { result: fail("EXPIRED", "credential validity window has passed"), issuerId };
+    }
+    if (await resolver.isRevoked(BigInt(claims.status.cn_zk_revocation.revocationCommitment))) {
+        return { result: fail("REVOKED", "credential commitment is in the revocation registry"), issuerId };
+    }
+    return { result: { ok: true, claims }, issuerId };
+}
+/**
+ * Verifies a compact SD-JWT credential with all its disclosures — the
+ * holder's verify-on-receipt and any check that does not involve a live
+ * presentation. Key binding is not checked here; that is verifyPresentation.
+ */
+async function verifySdJwtCredential(token, resolver, options) {
+    const now = options?.currentDate ?? Math.floor(Date.now() / 1000);
+    const { result } = await runPipeline(token, resolver, now, async (issuerJwk, clampedNow) => {
+        const sdjwt = new sd_jwt_vc_1.SDJwtVcInstance({
+            verifier: (0, crypto_1.createSdJwtVerifier)(issuerJwk),
+            hasher: crypto_1.sdJwtHasher,
+            hashAlg: "sha-256"
+        });
+        const { payload } = await sdjwt.verify(token, { currentDate: clampedNow });
+        return payload;
+    });
+    return result;
+}

package/dist/witness.d.ts

@@ -0,0 +1,12 @@
+import type { CompiledCircuit } from "@noir-lang/noir_js";
+import { ZkPresentationInputs } from "./presentation-inputs";
+type CircuitAbi = CompiledCircuit["abi"];
+/**
+ * Flattens {@link ZkPresentationInputs} into the ordered `string[]` witness a
+ * native Noir prover consumes, walking the compiled circuit's ABI (public and
+ * private parameters, in declaration order) rather than the JS object's own
+ * key order — a struct field reorder in the circuit changes the ABI and so
+ * changes this output, instead of silently desyncing from it.
+ */
+export declare function zkPresentationInputsToWitness(abi: CircuitAbi, inputs: ZkPresentationInputs): string[];
+export {};

package/dist/witness.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zkPresentationInputsToWitness = zkPresentationInputsToWitness;
+const DECIMAL_RE = /^(0|[1-9][0-9]*)$/;
+function scalarWitness(value, path) {
+    if (typeof value !== "string" || !DECIMAL_RE.test(value)) {
+        throw new Error(`zkPresentationInputsToWitness: ${path} must be a canonical decimal string`);
+    }
+    return value;
+}
+function booleanWitness(value, path) {
+    if (typeof value !== "boolean") {
+        throw new Error(`zkPresentationInputsToWitness: ${path} must be a boolean`);
+    }
+    return value ? "1" : "0";
+}
+/** Depth-first ABI walk (spec: field/integer -> decimal string, boolean -> "1"/"0", array/struct recurse). */
+function emit(type, value, path, witness) {
+    switch (type.kind) {
+        case "field":
+        case "integer":
+            witness.push(scalarWitness(value, path));
+            return;
+        case "boolean":
+            witness.push(booleanWitness(value, path));
+            return;
+        case "array":
+            if (!Array.isArray(value) || value.length !== type.length) {
+                throw new Error(`zkPresentationInputsToWitness: ${path} must be an array of length ${type.length}`);
+            }
+            value.forEach((element, index) => emit(type.type, element, `${path}[${index}]`, witness));
+            return;
+        case "struct": {
+            if (typeof value !== "object" || value === null || Array.isArray(value)) {
+                throw new Error(`zkPresentationInputsToWitness: ${path} must be an object`);
+            }
+            const fields = value;
+            type.fields.forEach((field) => emit(field.type, fields[field.name], `${path}.${field.name}`, witness));
+            return;
+        }
+        default:
+            throw new Error(`zkPresentationInputsToWitness: ${path} has unsupported ABI type "${type.kind}"`);
+    }
+}
+/**
+ * Flattens {@link ZkPresentationInputs} into the ordered `string[]` witness a
+ * native Noir prover consumes, walking the compiled circuit's ABI (public and
+ * private parameters, in declaration order) rather than the JS object's own
+ * key order — a struct field reorder in the circuit changes the ABI and so
+ * changes this output, instead of silently desyncing from it.
+ */
+function zkPresentationInputsToWitness(abi, inputs) {
+    const record = { ...inputs };
+    const witness = [];
+    for (const parameter of abi.parameters) {
+        if (!(parameter.name in record)) {
+            throw new Error(`zkPresentationInputsToWitness: unknown ABI parameter "${parameter.name}"`);
+        }
+        emit(parameter.type, record[parameter.name], parameter.name, witness);
+    }
+    return witness;
+}

package/dist/zk-proof.d.ts

@@ -0,0 +1,45 @@
+import type { BackendOptions, ProofData, UltraHonkBackendOptions } from "@aztec/bb.js";
+import type { CompiledCircuit } from "@noir-lang/noir_js";
+import { ZkPresentationInputs } from "./presentation-inputs";
+declare const PUBLIC_INPUT_NAMES: readonly ["current_time", "challenge", "audience", "required_programme_hash", "required_country_code"];
+type PublicInputName = (typeof PUBLIC_INPUT_NAMES)[number];
+export type ZkCredentialCircuit = CompiledCircuit;
+export type ZkPresentationProof = ProofData;
+export interface ExpectedZkPresentation {
+    currentTime: number;
+    challenge: Uint8Array;
+    audience: string;
+    programme: string;
+    country: string;
+}
+export type ZkPresentationVerifyResult = {
+    ok: true;
+    approvedIssuerRoot: bigint;
+    revocationRoot: bigint;
+} | {
+    ok: false;
+    code: "PUBLIC_INPUT_MISMATCH";
+    publicInput?: PublicInputName;
+} | {
+    ok: false;
+    code: "PROOF_INVALID";
+};
+export interface ZkProofSystemOptions {
+    backend?: BackendOptions;
+    proof?: UltraHonkBackendOptions;
+}
+export declare const assertZkCredentialCircuitAbi: (circuit: CompiledCircuit) => void;
+export declare class ZkCredentialProofSystem {
+    private readonly noir;
+    private readonly backend;
+    private readonly api;
+    private readonly proofOptions?;
+    private constructor();
+    static create(circuit: CompiledCircuit, options?: ZkProofSystemOptions): Promise<ZkCredentialProofSystem>;
+    generateProof(inputs: ZkPresentationInputs): Promise<ZkPresentationProof>;
+    verifyProof(proof: ZkPresentationProof, expected: ExpectedZkPresentation): Promise<ZkPresentationVerifyResult>;
+    destroy(): Promise<void>;
+}
+export declare function generateZkPresentationProof(circuit: CompiledCircuit, inputs: ZkPresentationInputs, options?: ZkProofSystemOptions): Promise<ZkPresentationProof>;
+export declare function verifyZkPresentationProof(circuit: CompiledCircuit, proof: ZkPresentationProof, expected: ExpectedZkPresentation, options?: ZkProofSystemOptions): Promise<ZkPresentationVerifyResult>;
+export {};