@coordination-network/credential 0.0.1

package/dist/issue-credential.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.issueZkCredential = issueZkCredential;
+const identity_1 = require("@coordination-network/identity");
+const utils_1 = require("@noble/hashes/utils");
+const identity_2 = require("@semaphore-protocol/identity");
+const credential_message_1 = require("./credential-message");
+const crypto_1 = require("./crypto");
+const errors_1 = require("./errors");
+const revocation_1 = require("./revocation");
+async function issueZkCredential(params, signer, approval) {
+    if (!(await approval.isApprovedNetworkMember(params.issuerNetworkId))) {
+        throw new errors_1.IssuanceError("ISSUER_NOT_APPROVED", `issuer ${params.issuerNetworkId} is not an approved network member`);
+    }
+    if (!(params.validFrom < params.validUntil)) {
+        throw new errors_1.IssuanceError("INVALID_PARAMS", "validFrom must be before validUntil");
+    }
+    const holderKeyCommitment = identity_2.Identity.generateCommitment(params.identityPublicKey);
+    const holderKeyCommitmentBytes = (0, utils_1.hexToBytes)(holderKeyCommitment.toString(16).padStart(64, "0"));
+    let binding;
+    try {
+        binding = (0, identity_1.verifyCredentialBinding)({
+            nonce: params.nonce,
+            accountPublicKey: params.accountPublicKey,
+            confirmationKey: (0, crypto_1.jwkToPublicKeyBytes)(params.confirmationKey),
+            holderKeyCommitment: holderKeyCommitmentBytes,
+            accountSignature: params.accountPopSignature,
+            deviceSignature: params.devicePopSignature
+        });
+    }
+    catch (error) {
+        if (error instanceof identity_1.InvalidBindingInputError) {
+            throw new errors_1.IssuanceError("INVALID_PARAMS", `malformed binding input: ${error.message}`);
+        }
+        throw error;
+    }
+    if (binding.networkId !== params.subjectNetworkId.toLowerCase()) {
+        throw new errors_1.IssuanceError("SUBJECT_MISMATCH", "subjectNetworkId does not match the account public key");
+    }
+    if (!binding.valid) {
+        throw new errors_1.IssuanceError("BINDING_INVALID", "credential binding failed");
+    }
+    const ownershipOk = (0, revocation_1.verifyCommitmentOwnership)({
+        commitment: params.revocation.commitment,
+        publicKey: params.revocation.publicKey,
+        signature: params.revocation.ownershipSignature,
+        nonce: params.nonce
+    });
+    if (!ownershipOk) {
+        throw new errors_1.IssuanceError("COMMITMENT_OWNERSHIP_INVALID", "revocation commitment ownership proof failed");
+    }
+    const body = {
+        programmeHash: (0, credential_message_1.programmeHash)(params.approvalScope.programme),
+        countryCode: (0, credential_message_1.countryCode)(params.approvalScope.country),
+        notBefore: params.validFrom,
+        expiresAt: params.validUntil,
+        deviceKeyCommitment: (0, credential_message_1.deriveDeviceKeyCommitment)(params.confirmationKey),
+        holderKeyCommitment,
+        revocationCommitment: params.revocation.commitment
+    };
+    return {
+        body,
+        issuerPublicKey: await signer.getPublicKey(),
+        signature: await signer.sign((0, credential_message_1.zkCredentialCommitment)(body))
+    };
+}

package/dist/issue.d.ts

@@ -0,0 +1,9 @@
+import { ApprovalResolver } from "./resolver";
+import { Signer } from "./signer";
+import { SdJwtIssueParams } from "./types";
+/**
+ * Issues the delegated user approval credential (spec 07, issuance flow).
+ * Throws IssuanceError, without signing anything, if the issuer isn't
+ * approved or any challenge signature fails.
+ */
+export declare function issueSdJwtCredential(params: SdJwtIssueParams, signer: Signer, approval: ApprovalResolver): Promise<string>;

package/dist/issue.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.issueSdJwtCredential = issueSdJwtCredential;
+const sd_jwt_vc_1 = require("@sd-jwt/sd-jwt-vc");
+const identity_1 = require("@coordination-network/identity");
+const crypto_1 = require("./crypto");
+const errors_1 = require("./errors");
+const profile_1 = require("./profile");
+const revocation_1 = require("./revocation");
+/**
+ * Issues the delegated user approval credential (spec 07, issuance flow).
+ * Throws IssuanceError, without signing anything, if the issuer isn't
+ * approved or any challenge signature fails.
+ */
+async function issueSdJwtCredential(params, signer, approval) {
+    if (!(await approval.isApprovedNetworkMember(params.issuerNetworkId))) {
+        throw new errors_1.IssuanceError("ISSUER_NOT_APPROVED", `issuer ${params.issuerNetworkId} is not an approved network member`);
+    }
+    if (!(params.validFrom < params.validUntil)) {
+        throw new errors_1.IssuanceError("INVALID_PARAMS", "validFrom must be before validUntil");
+    }
+    let binding;
+    try {
+        binding = (0, identity_1.verifyCredentialBinding)({
+            nonce: params.nonce,
+            accountPublicKey: params.accountPublicKey,
+            confirmationKey: (0, crypto_1.jwkToPublicKeyBytes)(params.confirmationKey),
+            accountSignature: params.accountPopSignature,
+            deviceSignature: params.devicePopSignature
+        });
+    }
+    catch (error) {
+        if (error instanceof identity_1.InvalidBindingInputError) {
+            throw new errors_1.IssuanceError("INVALID_PARAMS", `malformed binding input: ${error.message}`);
+        }
+        throw error;
+    }
+    if (binding.networkId !== params.subjectNetworkId.toLowerCase()) {
+        throw new errors_1.IssuanceError("SUBJECT_MISMATCH", "subjectNetworkId does not match the account public key");
+    }
+    if (!binding.valid) {
+        throw new errors_1.IssuanceError("BINDING_INVALID", "credential binding failed");
+    }
+    const ownershipOk = (0, revocation_1.verifyCommitmentOwnership)({
+        commitment: params.revocation.commitment,
+        publicKey: params.revocation.publicKey,
+        signature: params.revocation.ownershipSignature,
+        nonce: params.nonce
+    });
+    if (!ownershipOk) {
+        throw new errors_1.IssuanceError("COMMITMENT_OWNERSHIP_INVALID", "revocation commitment ownership proof failed");
+    }
+    const payload = (0, profile_1.buildPayload)({ ...params, subjectNetworkId: binding.networkId }, `urn:uuid:${(0, crypto_1.randomUuid)()}`);
+    const sdjwt = new sd_jwt_vc_1.SDJwtVcInstance({
+        signer: (0, crypto_1.createSdJwtSigner)(signer),
+        signAlg: "ES256",
+        hasher: crypto_1.sdJwtHasher,
+        hashAlg: "sha-256",
+        saltGenerator: crypto_1.sdJwtSaltGenerator
+    });
+    // Cast: the library types `status` as its own status-list reference, but
+    // our custom cn_zk_revocation member is deliberate (spec 07) and the
+    // status-list fetcher only triggers on status.status_list.
+    return sdjwt.issue({ ...payload }, profile_1.DISCLOSURE_FRAME);
+}

package/dist/issuer-set.d.ts

@@ -0,0 +1,2 @@
+export { ApprovedIssuerSet, ISSUER_LEAF_DOMAIN, ISSUER_SET_MAX_DEPTH, issuerLeaf } from "@coordination-network/issuer-set";
+export type { IssuerMembershipProof, IssuerSet } from "@coordination-network/issuer-set";

package/dist/issuer-set.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.issuerLeaf = exports.ISSUER_SET_MAX_DEPTH = exports.ISSUER_LEAF_DOMAIN = exports.ApprovedIssuerSet = void 0;
+// The approved-issuer set now lives in @coordination-network/issuer-set, which the ApprovedIssuerSet.sol
+// contract's TypeScript mirror also builds on. Re-exported here so every existing import of this module
+// keeps working unchanged.
+var issuer_set_1 = require("@coordination-network/issuer-set");
+Object.defineProperty(exports, "ApprovedIssuerSet", { enumerable: true, get: function () { return issuer_set_1.ApprovedIssuerSet; } });
+Object.defineProperty(exports, "ISSUER_LEAF_DOMAIN", { enumerable: true, get: function () { return issuer_set_1.ISSUER_LEAF_DOMAIN; } });
+Object.defineProperty(exports, "ISSUER_SET_MAX_DEPTH", { enumerable: true, get: function () { return issuer_set_1.ISSUER_SET_MAX_DEPTH; } });
+Object.defineProperty(exports, "issuerLeaf", { enumerable: true, get: function () { return issuer_set_1.issuerLeaf; } });

package/dist/present.d.ts

@@ -0,0 +1,32 @@
+import { Resolver } from "./resolver";
+import { DeviceSigner } from "./signer";
+import { VerifyResult } from "./types";
+export interface PresentOptions {
+    /** Verifier URN, pinned as the KB-JWT audience. */
+    audience: string;
+    /** Verifier-issued nonce, echoed in the KB-JWT. */
+    nonce: string;
+    /** Which approvalScope members to disclose. Both when omitted. */
+    disclose?: ("programme" | "country")[];
+}
+export interface VerifyPresentationOptions {
+    /** The verifier's own URN; the KB-JWT audience must match it. */
+    audience: string;
+    /** The nonce this verifier handed out; must be fresh and match. */
+    nonce: string;
+    /** Verification time, unix seconds. Defaults to now. */
+    currentDate?: number;
+}
+/**
+ * Builds a presentation from a stored credential: the JWS, the selected
+ * disclosures, and a KB-JWT signed by the device key binding the verifier's
+ * audience, the nonce and the sd_hash of the exact presented token (spec 07,
+ * verification flow step 7).
+ */
+export declare function presentSdJwtCredential(token: string, deviceSigner: DeviceSigner, options: PresentOptions): Promise<string>;
+/**
+ * Verifies a presentation: the full verifyCredential pipeline, plus the
+ * KB-JWT under the credential's cnf.jwk with nonce, sd_hash (both checked by
+ * the library) and audience (checked here) pinned.
+ */
+export declare function verifySdJwtPresentation(presentation: string, resolver: Resolver, options: VerifyPresentationOptions): Promise<VerifyResult>;

package/dist/present.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.presentSdJwtCredential = presentSdJwtCredential;
+exports.verifySdJwtPresentation = verifySdJwtPresentation;
+const sd_jwt_vc_1 = require("@sd-jwt/sd-jwt-vc");
+const crypto_1 = require("./crypto");
+const verify_1 = require("./verify");
+/**
+ * Builds a presentation from a stored credential: the JWS, the selected
+ * disclosures, and a KB-JWT signed by the device key binding the verifier's
+ * audience, the nonce and the sd_hash of the exact presented token (spec 07,
+ * verification flow step 7).
+ */
+async function presentSdJwtCredential(token, deviceSigner, options) {
+    const disclose = options.disclose ?? ["programme", "country"];
+    const frame = { approvalScope: Object.fromEntries(disclose.map((member) => [member, true])) };
+    const sdjwt = new sd_jwt_vc_1.SDJwtVcInstance({
+        hasher: crypto_1.sdJwtHasher,
+        hashAlg: "sha-256",
+        saltGenerator: crypto_1.sdJwtSaltGenerator,
+        kbSigner: (0, crypto_1.createSdJwtSigner)(deviceSigner),
+        kbSignAlg: "ES256"
+    });
+    return sdjwt.present(token, frame, {
+        kb: {
+            payload: {
+                aud: options.audience,
+                nonce: options.nonce,
+                iat: Math.floor(Date.now() / 1000)
+            }
+        }
+    });
+}
+/**
+ * Verifies a presentation: the full verifyCredential pipeline, plus the
+ * KB-JWT under the credential's cnf.jwk with nonce, sd_hash (both checked by
+ * the library) and audience (checked here) pinned.
+ */
+async function verifySdJwtPresentation(presentation, resolver, options) {
+    const now = options.currentDate ?? Math.floor(Date.now() / 1000);
+    let audience;
+    const { result } = await (0, verify_1.runPipeline)(presentation, 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",
+            kbVerifier: (data, signature, payload) => {
+                const cnfJwk = payload.cnf?.jwk;
+                if (!cnfJwk)
+                    return false;
+                try {
+                    return (0, crypto_1.createSdJwtVerifier)(cnfJwk)(data, signature);
+                }
+                catch {
+                    return false;
+                }
+            }
+        });
+        const { payload, kb } = await sdjwt.verify(presentation, {
+            currentDate: clampedNow,
+            keyBindingNonce: options.nonce
+        });
+        audience = kb?.payload.aud;
+        return payload;
+    });
+    if (!result.ok) {
+        return result;
+    }
+    if (audience !== options.audience) {
+        return { ok: false, code: "PROOF_INVALID", message: "KB-JWT audience does not match this verifier" };
+    }
+    return result;
+}

package/dist/presentation-inputs.d.ts

@@ -0,0 +1,77 @@
+import { IssuerSet } from "./issuer-set";
+import { DeviceSigner } from "./signer";
+export declare const REVOCATION_MAX_DEPTH = 20;
+export declare const PRESENTATION_DOMAIN: bigint;
+export interface ZkPresentationInputs {
+    current_time: string;
+    challenge: string;
+    audience: string;
+    required_programme_hash: string;
+    required_country_code: string;
+    credential: {
+        programme_hash: string;
+        country_code: string;
+        not_before: string;
+        expires_at: string;
+        device_key_commitment: string;
+        holder_key_commitment: string;
+        revocation_commitment: string;
+    };
+    issuer_pub_x: string;
+    issuer_pub_y: string;
+    issuer_sig_r8_x: string;
+    issuer_sig_r8_y: string;
+    issuer_sig_s: string;
+    issuer_depth: string;
+    issuer_indices: boolean[];
+    issuer_siblings: string[];
+    device_pub_x: string[];
+    device_pub_y: string[];
+    device_signature: string[];
+    identity_pub_x: string;
+    identity_pub_y: string;
+    identity_sig_r8_x: string;
+    identity_sig_r8_y: string;
+    identity_sig_s: string;
+    revocation_pub_x: string;
+    revocation_pub_y: string;
+    revocation_sig_r8_x: string;
+    revocation_sig_r8_y: string;
+    revocation_sig_s: string;
+    revocation_low_leaf_value: string;
+    revocation_low_leaf_next: string;
+    revocation_depth: string;
+    revocation_indices: boolean[];
+    revocation_siblings: string[];
+}
+export interface ZkPresentationHolder {
+    identitySeed: Uint8Array;
+    revocationSecret: Uint8Array;
+    deviceSigner: DeviceSigner;
+}
+export interface IndexedTree {
+    root: bigint;
+    generateProof(value: bigint): {
+        proofType: 0 | 1;
+        root: bigint;
+        leaf: {
+            value: bigint;
+            nextValue: bigint;
+        };
+        leafIndex: number;
+        siblings: bigint[];
+    };
+}
+export interface ZkPresentationChainState {
+    approvedIssuers: IssuerSet;
+    revocations: IndexedTree;
+}
+export interface ZkPresentationRequest {
+    challenge: Uint8Array;
+    audience: string;
+    currentTime: number;
+    programme: string;
+    country: string;
+}
+export declare const challengeToField: (bytes: Uint8Array) => bigint;
+export declare function buildZkPresentationInputs(serializedCredential: unknown, holder: ZkPresentationHolder, chain: ZkPresentationChainState, request: ZkPresentationRequest): Promise<ZkPresentationInputs>;

package/dist/presentation-inputs.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.challengeToField = exports.PRESENTATION_DOMAIN = exports.REVOCATION_MAX_DEPTH = void 0;
+exports.buildZkPresentationInputs = buildZkPresentationInputs;
+const identity_1 = require("@semaphore-protocol/identity");
+const poseidon2_1 = require("poseidon-lite/poseidon2");
+const poseidon4_1 = require("poseidon-lite/poseidon4");
+const utils_1 = require("@noble/hashes/utils");
+const credential_message_1 = require("./credential-message");
+const crypto_1 = require("./crypto");
+const issuer_set_1 = require("./issuer-set");
+exports.REVOCATION_MAX_DEPTH = 20;
+// keccak256(utf8("urn:cn:presentation:v1")) >> 8
+exports.PRESENTATION_DOMAIN = BigInt("47717037732995119958831198142288202228464361330145547649000821135537239485");
+const challengeToField = (bytes) => {
+    if (bytes.length !== 31)
+        throw new Error("presentation challenge must be exactly 31 bytes");
+    return BigInt(`0x${(0, utils_1.bytesToHex)(bytes)}`);
+};
+exports.challengeToField = challengeToField;
+const fieldToBytes = (value) => (0, utils_1.hexToBytes)(value.toString(16).padStart(64, "0"));
+const pathIndices = (leafIndex, depth) => Array.from({ length: depth }, (_, index) => ((leafIndex >> index) & 1) === 1);
+function padPath(leafIndex, siblings, maxDepth, label) {
+    const depth = siblings.length;
+    if (depth > maxDepth) {
+        throw new Error(`${label} path depth ${depth} exceeds the circuit maximum of ${maxDepth}`);
+    }
+    const pad = (values, filler) => [...values, ...Array(maxDepth - values.length).fill(filler)];
+    return {
+        depth: depth.toString(),
+        indices: pad(pathIndices(leafIndex, depth), false),
+        siblings: pad(siblings, 0n).map(String)
+    };
+}
+function issuerPath(issuerSet, publicKey) {
+    const proof = issuerSet.generateProof(publicKey);
+    if (proof.root !== issuerSet.root)
+        throw new Error("issuer proof root does not match the approved issuer set");
+    const padded = padPath(proof.pathIndex, proof.siblings, issuer_set_1.ISSUER_SET_MAX_DEPTH, "issuer");
+    const depth = proof.siblings.length;
+    if (!Number.isSafeInteger(proof.pathIndex) || proof.pathIndex < 0 || proof.pathIndex >= 2 ** depth) {
+        throw new Error("issuer proof has an invalid path index");
+    }
+    let node = (0, issuer_set_1.issuerLeaf)(publicKey);
+    for (let level = 0; level < depth; level += 1) {
+        node = padded.indices[level]
+            ? (0, poseidon2_1.poseidon2)([proof.siblings[level], node])
+            : (0, poseidon2_1.poseidon2)([node, proof.siblings[level]]);
+    }
+    if (node !== proof.root)
+        throw new Error("issuer proof is invalid");
+    return padded;
+}
+async function buildZkPresentationInputs(serializedCredential, holder, chain, request) {
+    const credential = (0, credential_message_1.parseZkCredential)(serializedCredential);
+    if (!(0, credential_message_1.verifyZkCredential)(credential))
+        throw new Error("credential issuer signature is invalid");
+    const { body } = credential;
+    const identity = new identity_1.Identity(holder.identitySeed);
+    if (identity.commitment !== body.holderKeyCommitment) {
+        throw new Error("identity seed does not open the credential's holder-key commitment");
+    }
+    const revocation = new identity_1.Identity(holder.revocationSecret);
+    if (revocation.commitment !== body.revocationCommitment) {
+        throw new Error("revocation secret does not open the credential's revocation commitment");
+    }
+    const devicePublicKey = await holder.deviceSigner.getPublicKeyJwk();
+    if ((0, credential_message_1.deriveDeviceKeyCommitment)(devicePublicKey) !== body.deviceKeyCommitment) {
+        throw new Error("device signer does not open the credential's device-key commitment");
+    }
+    const issuer = issuerPath(chain.approvedIssuers, credential.issuerPublicKey);
+    const revocationProof = chain.revocations.root === 0n
+        ? {
+            proofType: 1,
+            root: 0n,
+            leaf: { value: 0n, nextValue: 0n },
+            leafIndex: 0,
+            siblings: []
+        }
+        : chain.revocations.generateProof(body.revocationCommitment);
+    if (revocationProof.root !== chain.revocations.root) {
+        throw new Error("revocation proof root does not match the supplied revocation tree");
+    }
+    if (revocationProof.proofType !== 1)
+        throw new Error("credential is revoked");
+    const revocationPath = padPath(revocationProof.leafIndex, revocationProof.siblings, exports.REVOCATION_MAX_DEPTH, "revocation");
+    const challenge = (0, exports.challengeToField)(request.challenge);
+    const audience = (0, credential_message_1.stringToField)(request.audience);
+    const credentialCommitment = (0, credential_message_1.zkCredentialCommitment)(body);
+    const sessionMessage = (0, poseidon4_1.poseidon4)([exports.PRESENTATION_DOMAIN, challenge, audience, credentialCommitment]);
+    const identitySignature = identity.signMessage(sessionMessage);
+    const revocationSignature = revocation.signMessage(sessionMessage);
+    const deviceSignature = await holder.deviceSigner.signDigest(fieldToBytes(sessionMessage));
+    if (deviceSignature.length !== 64)
+        throw new Error("device signer must return a compact 64-byte signature");
+    const encodedDeviceKey = (0, crypto_1.jwkToPublicKeyBytes)(devicePublicKey);
+    return {
+        current_time: String(request.currentTime),
+        challenge: String(challenge),
+        audience: String(audience),
+        required_programme_hash: String((0, credential_message_1.programmeHash)(request.programme)),
+        required_country_code: String((0, credential_message_1.countryCode)(request.country)),
+        credential: {
+            programme_hash: String(body.programmeHash),
+            country_code: String(body.countryCode),
+            not_before: String(body.notBefore),
+            expires_at: String(body.expiresAt),
+            device_key_commitment: String(body.deviceKeyCommitment),
+            holder_key_commitment: String(body.holderKeyCommitment),
+            revocation_commitment: String(body.revocationCommitment)
+        },
+        issuer_pub_x: String(credential.issuerPublicKey[0]),
+        issuer_pub_y: String(credential.issuerPublicKey[1]),
+        issuer_sig_r8_x: String(credential.signature.R8[0]),
+        issuer_sig_r8_y: String(credential.signature.R8[1]),
+        issuer_sig_s: String(credential.signature.S),
+        issuer_depth: issuer.depth,
+        issuer_indices: issuer.indices,
+        issuer_siblings: issuer.siblings,
+        device_pub_x: Array.from(encodedDeviceKey.slice(1, 33), String),
+        device_pub_y: Array.from(encodedDeviceKey.slice(33, 65), String),
+        device_signature: Array.from(deviceSignature, String),
+        identity_pub_x: String(identity.publicKey[0]),
+        identity_pub_y: String(identity.publicKey[1]),
+        identity_sig_r8_x: String(identitySignature.R8[0]),
+        identity_sig_r8_y: String(identitySignature.R8[1]),
+        identity_sig_s: String(identitySignature.S),
+        revocation_pub_x: String(revocation.publicKey[0]),
+        revocation_pub_y: String(revocation.publicKey[1]),
+        revocation_sig_r8_x: String(revocationSignature.R8[0]),
+        revocation_sig_r8_y: String(revocationSignature.R8[1]),
+        revocation_sig_s: String(revocationSignature.S),
+        revocation_low_leaf_value: String(revocationProof.leaf.value),
+        revocation_low_leaf_next: String(revocationProof.leaf.nextValue),
+        revocation_depth: revocationPath.depth,
+        revocation_indices: revocationPath.indices,
+        revocation_siblings: revocationPath.siblings
+    };
+}

package/dist/profile.d.ts

@@ -0,0 +1,32 @@
+import { ApprovalCredentialClaims, Hex32, SdJwtIssueParams } from "./types";
+/**
+ * The claims profile of the delegated user approval credential (spec 07):
+ * payload construction, the disclosure frame, and the shape validator that
+ * backs the MALFORMED verdict.
+ */
+export declare const APPROVAL_CREDENTIAL_VCT = "urn:cn:credential:approval:v1";
+/** Only the two approvalScope members are disclosable; everything else is plain. */
+export declare const DISCLOSURE_FRAME: {
+    readonly approvalScope: {
+        readonly _sd: readonly ["programme", "country"];
+    };
+};
+export declare function networkIdToUrn(id: Hex32): string;
+export declare function urnToNetworkId(urn: string): Hex32 | null;
+/** Assembles the full signed payload; the disclosure frame is applied at issue time. */
+export declare function buildPayload(params: SdJwtIssueParams, jti: string): ApprovalCredentialClaims;
+type ClaimsCheck = {
+    ok: true;
+    claims: ApprovalCredentialClaims;
+} | {
+    ok: false;
+    message: string;
+};
+/**
+ * Validates the reconstructed payload of a verified token against the
+ * profile. Strict on both sides: a missing required claim and an unknown
+ * plain claim both fail (spec 07; a tampered disclosure surfaces here as a
+ * missing approvalScope member).
+ */
+export declare function validateClaims(payload: unknown): ClaimsCheck;
+export {};

package/dist/profile.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DISCLOSURE_FRAME = exports.APPROVAL_CREDENTIAL_VCT = void 0;
+exports.networkIdToUrn = networkIdToUrn;
+exports.urnToNetworkId = urnToNetworkId;
+exports.buildPayload = buildPayload;
+exports.validateClaims = validateClaims;
+const revocation_1 = require("./revocation");
+/**
+ * The claims profile of the delegated user approval credential (spec 07):
+ * payload construction, the disclosure frame, and the shape validator that
+ * backs the MALFORMED verdict.
+ */
+exports.APPROVAL_CREDENTIAL_VCT = "urn:cn:credential:approval:v1";
+/** Only the two approvalScope members are disclosable; everything else is plain. */
+exports.DISCLOSURE_FRAME = {
+    approvalScope: { _sd: ["programme", "country"] }
+};
+const NETWORK_ID_RE = /^0x[0-9a-f]{64}$/;
+const NETWORK_URN_RE = /^urn:cn:network:[0-9a-f]{64}$/;
+const CONTRACT_URN_RE = /^urn:cn:contract:.+$/;
+const UUID_URN_RE = /^urn:uuid:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+function networkIdToUrn(id) {
+    const normalized = id.toLowerCase();
+    if (!NETWORK_ID_RE.test(normalized)) {
+        throw new Error("networkId must be a 0x-prefixed 32-byte hex string");
+    }
+    return `urn:cn:network:${normalized.slice(2)}`;
+}
+function urnToNetworkId(urn) {
+    return NETWORK_URN_RE.test(urn) ? `0x${urn.slice("urn:cn:network:".length)}` : null;
+}
+/** Assembles the full signed payload; the disclosure frame is applied at issue time. */
+function buildPayload(params, jti) {
+    return {
+        vct: exports.APPROVAL_CREDENTIAL_VCT,
+        iss: networkIdToUrn(params.issuerNetworkId),
+        sub: networkIdToUrn(params.subjectNetworkId),
+        jti,
+        nbf: params.validFrom,
+        exp: params.validUntil,
+        cnf: { jwk: params.confirmationKey },
+        status: (0, revocation_1.buildStatusClaim)(params.revocation.commitment, params.revocationRegistry),
+        approvalScope: { ...params.approvalScope }
+    };
+}
+const ALLOWED_TOP_LEVEL = new Set(["vct", "iss", "sub", "jti", "nbf", "exp", "cnf", "status", "approvalScope"]);
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isJwk(value) {
+    if (!isRecord(value))
+        return false;
+    const keys = Object.keys(value);
+    return (keys.length === 4 &&
+        value.kty === "EC" &&
+        value.crv === "P-256" &&
+        typeof value.x === "string" &&
+        typeof value.y === "string");
+}
+function isStatusClaim(value) {
+    if (!isRecord(value) || Object.keys(value).length !== 1)
+        return false;
+    const entry = value.cn_zk_revocation;
+    if (!isRecord(entry) || Object.keys(entry).length !== 2)
+        return false;
+    return (typeof entry.revocationRegistry === "string" &&
+        CONTRACT_URN_RE.test(entry.revocationRegistry) &&
+        typeof entry.revocationCommitment === "string" &&
+        /^[0-9]+$/.test(entry.revocationCommitment));
+}
+function isApprovalScope(value) {
+    if (!isRecord(value))
+        return false;
+    const keys = Object.keys(value);
+    return (keys.length === 2 &&
+        typeof value.programme === "string" &&
+        value.programme.length > 0 &&
+        typeof value.country === "string" &&
+        /^[A-Z]{3}$/.test(value.country));
+}
+/**
+ * Validates the reconstructed payload of a verified token against the
+ * profile. Strict on both sides: a missing required claim and an unknown
+ * plain claim both fail (spec 07; a tampered disclosure surfaces here as a
+ * missing approvalScope member).
+ */
+function validateClaims(payload) {
+    if (!isRecord(payload)) {
+        return { ok: false, message: "payload is not an object" };
+    }
+    for (const key of Object.keys(payload)) {
+        if (!ALLOWED_TOP_LEVEL.has(key)) {
+            return { ok: false, message: `unknown claim: ${key}` };
+        }
+    }
+    if (payload.vct !== exports.APPROVAL_CREDENTIAL_VCT) {
+        return { ok: false, message: "vct missing or not the approval credential type" };
+    }
+    if (typeof payload.iss !== "string" || urnToNetworkId(payload.iss) === null) {
+        return { ok: false, message: "iss missing or not a urn:cn:network URN" };
+    }
+    if (typeof payload.sub !== "string" || urnToNetworkId(payload.sub) === null) {
+        return { ok: false, message: "sub missing or not a urn:cn:network URN" };
+    }
+    if (typeof payload.jti !== "string" || !UUID_URN_RE.test(payload.jti)) {
+        return { ok: false, message: "jti missing or not a urn:uuid URN" };
+    }
+    if (typeof payload.nbf !== "number" || typeof payload.exp !== "number") {
+        return { ok: false, message: "nbf/exp missing or not NumericDate values" };
+    }
+    if (!isRecord(payload.cnf) || Object.keys(payload.cnf).length !== 1 || !isJwk(payload.cnf.jwk)) {
+        return { ok: false, message: "cnf.jwk missing or not a P-256 JWK" };
+    }
+    if (!isStatusClaim(payload.status)) {
+        return { ok: false, message: "status.cn_zk_revocation missing or malformed" };
+    }
+    if (!isApprovalScope(payload.approvalScope)) {
+        return { ok: false, message: "approvalScope missing programme/country" };
+    }
+    return { ok: true, claims: payload };
+}

package/dist/registry-client.d.ts

@@ -0,0 +1,12 @@
+import { Hex32 } from "./types";
+/**
+ * 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.
+ */
+export declare class NetworkMemberRegistryClient {
+    private readonly registryAddress;
+    private readonly client;
+    constructor(registryAddress: `0x${string}`, rpcUrl: string);
+    isApprovedNetworkMember(id: Hex32): Promise<boolean>;
+}