@coordination-network/credential 0.0.1

package/src/issue.ts

@@ -0,0 +1,83 @@
+import { SDJwtVcInstance, SdJwtVcPayload } from "@sd-jwt/sd-jwt-vc"
+import { DisclosureFrame } from "@sd-jwt/types"
+import { InvalidBindingInputError, verifyCredentialBinding } from "@coordination-network/identity"
+import { createSdJwtSigner, jwkToPublicKeyBytes, randomUuid, sdJwtHasher, sdJwtSaltGenerator } from "./crypto"
+import { IssuanceError } from "./errors"
+import { buildPayload, DISCLOSURE_FRAME } from "./profile"
+import { ApprovalResolver } from "./resolver"
+import { verifyCommitmentOwnership } from "./revocation"
+import { Signer } from "./signer"
+import { Hex32, 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 async function issueSdJwtCredential(
+    params: SdJwtIssueParams,
+    signer: Signer,
+    approval: ApprovalResolver
+): Promise<string> {
+    if (!(await approval.isApprovedNetworkMember(params.issuerNetworkId))) {
+        throw new IssuanceError(
+            "ISSUER_NOT_APPROVED",
+            `issuer ${params.issuerNetworkId} is not an approved network member`
+        )
+    }
+    if (!(params.validFrom < params.validUntil)) {
+        throw new IssuanceError("INVALID_PARAMS", "validFrom must be before validUntil")
+    }
+
+    let binding: ReturnType<typeof verifyCredentialBinding>
+    try {
+        binding = verifyCredentialBinding({
+            nonce: params.nonce,
+            accountPublicKey: params.accountPublicKey,
+            confirmationKey: jwkToPublicKeyBytes(params.confirmationKey),
+            accountSignature: params.accountPopSignature,
+            deviceSignature: params.devicePopSignature
+        })
+    } catch (error) {
+        if (error instanceof InvalidBindingInputError) {
+            throw new IssuanceError("INVALID_PARAMS", `malformed binding input: ${error.message}`)
+        }
+        throw error
+    }
+
+    if (binding.networkId !== params.subjectNetworkId.toLowerCase()) {
+        throw new IssuanceError("SUBJECT_MISMATCH", "subjectNetworkId does not match the account public key")
+    }
+    if (!binding.valid) {
+        throw new IssuanceError("BINDING_INVALID", "credential binding failed")
+    }
+
+    const ownershipOk = verifyCommitmentOwnership({
+        commitment: params.revocation.commitment,
+        publicKey: params.revocation.publicKey,
+        signature: params.revocation.ownershipSignature,
+        nonce: params.nonce
+    })
+    if (!ownershipOk) {
+        throw new IssuanceError("COMMITMENT_OWNERSHIP_INVALID", "revocation commitment ownership proof failed")
+    }
+
+    const payload = buildPayload(
+        { ...params, subjectNetworkId: binding.networkId as Hex32 },
+        `urn:uuid:${randomUuid()}`
+    )
+    const sdjwt = new SDJwtVcInstance({
+        signer: createSdJwtSigner(signer),
+        signAlg: "ES256",
+        hasher: sdJwtHasher,
+        hashAlg: "sha-256",
+        saltGenerator: 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 } as unknown as SdJwtVcPayload,
+        DISCLOSURE_FRAME as unknown as DisclosureFrame<SdJwtVcPayload>
+    )
+}

package/src/issuer-set.ts

@@ -0,0 +1,10 @@
+// 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.
+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/src/present.ts

@@ -0,0 +1,101 @@
+import { SDJwtVcInstance } from "@sd-jwt/sd-jwt-vc"
+import { JwtPayload, PresentationFrame } from "@sd-jwt/types"
+import { createSdJwtSigner, createSdJwtVerifier, sdJwtHasher, sdJwtSaltGenerator } from "./crypto"
+import { Resolver } from "./resolver"
+import { DeviceSigner } from "./signer"
+import { Jwk, VerifyResult } from "./types"
+import { runPipeline } from "./verify"
+
+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 async function presentSdJwtCredential(
+    token: string,
+    deviceSigner: DeviceSigner,
+    options: PresentOptions
+): Promise<string> {
+    const disclose = options.disclose ?? ["programme", "country"]
+    const frame = { approvalScope: Object.fromEntries(disclose.map((member) => [member, true])) }
+    const sdjwt = new SDJwtVcInstance({
+        hasher: sdJwtHasher,
+        hashAlg: "sha-256",
+        saltGenerator: sdJwtSaltGenerator,
+        kbSigner: createSdJwtSigner(deviceSigner),
+        kbSignAlg: "ES256"
+    })
+    return sdjwt.present(token, frame as unknown as PresentationFrame<Record<string, unknown>>, {
+        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.
+ */
+export async function verifySdJwtPresentation(
+    presentation: string,
+    resolver: Resolver,
+    options: VerifyPresentationOptions
+): Promise<VerifyResult> {
+    const now = options.currentDate ?? Math.floor(Date.now() / 1000)
+    let audience: string | undefined
+
+    const { result } = await runPipeline(presentation, resolver, now, async (issuerJwk: Jwk, clampedNow: number) => {
+        const sdjwt = new SDJwtVcInstance({
+            verifier: createSdJwtVerifier(issuerJwk),
+            hasher: sdJwtHasher,
+            hashAlg: "sha-256",
+            kbVerifier: (data: string, signature: string, payload: JwtPayload) => {
+                const cnfJwk = (payload as { cnf?: { jwk?: Jwk } }).cnf?.jwk
+                if (!cnfJwk) return false
+                try {
+                    return 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/src/presentation-inputs.ts

@@ -0,0 +1,245 @@
+import { Identity } from "@semaphore-protocol/identity"
+import { poseidon2 } from "poseidon-lite/poseidon2"
+import { poseidon4 } from "poseidon-lite/poseidon4"
+import { bytesToHex, hexToBytes } from "@noble/hashes/utils"
+import {
+    countryCode,
+    deriveDeviceKeyCommitment,
+    parseZkCredential,
+    programmeHash,
+    stringToField,
+    verifyZkCredential,
+    zkCredentialCommitment
+} from "./credential-message"
+import { jwkToPublicKeyBytes } from "./crypto"
+import { issuerLeaf, ISSUER_SET_MAX_DEPTH, IssuerSet } from "./issuer-set"
+import { DeviceSigner } from "./signer"
+
+export const REVOCATION_MAX_DEPTH = 20
+// keccak256(utf8("urn:cn:presentation:v1")) >> 8
+export const PRESENTATION_DOMAIN = BigInt("47717037732995119958831198142288202228464361330145547649000821135537239485")
+
+interface PaddedPath {
+    depth: string
+    indices: boolean[]
+    siblings: string[]
+}
+
+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 const challengeToField = (bytes: Uint8Array): bigint => {
+    if (bytes.length !== 31) throw new Error("presentation challenge must be exactly 31 bytes")
+    return BigInt(`0x${bytesToHex(bytes)}`)
+}
+
+const fieldToBytes = (value: bigint): Uint8Array => hexToBytes(value.toString(16).padStart(64, "0"))
+
+const pathIndices = (leafIndex: number, depth: number): boolean[] =>
+    Array.from({ length: depth }, (_, index) => ((leafIndex >> index) & 1) === 1)
+
+function padPath(leafIndex: number, siblings: bigint[], maxDepth: number, label: string): PaddedPath {
+    const depth = siblings.length
+    if (depth > maxDepth) {
+        throw new Error(`${label} path depth ${depth} exceeds the circuit maximum of ${maxDepth}`)
+    }
+    const pad = <T>(values: T[], filler: T) => [...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: IssuerSet, publicKey: [bigint, bigint]): PaddedPath {
+    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_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 = issuerLeaf(publicKey)
+    for (let level = 0; level < depth; level += 1) {
+        node = padded.indices[level]
+            ? poseidon2([proof.siblings[level], node])
+            : poseidon2([node, proof.siblings[level]])
+    }
+    if (node !== proof.root) throw new Error("issuer proof is invalid")
+
+    return padded
+}
+
+export async function buildZkPresentationInputs(
+    serializedCredential: unknown,
+    holder: ZkPresentationHolder,
+    chain: ZkPresentationChainState,
+    request: ZkPresentationRequest
+): Promise<ZkPresentationInputs> {
+    const credential = parseZkCredential(serializedCredential)
+    if (!verifyZkCredential(credential)) throw new Error("credential issuer signature is invalid")
+    const { body } = credential
+
+    const identity = new 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(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 (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 as const,
+                  root: 0n,
+                  leaf: { value: 0n, nextValue: 0n },
+                  leafIndex: 0,
+                  siblings: [] as bigint[]
+              }
+            : 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,
+        REVOCATION_MAX_DEPTH,
+        "revocation"
+    )
+
+    const challenge = challengeToField(request.challenge)
+    const audience = stringToField(request.audience)
+    const credentialCommitment = zkCredentialCommitment(body)
+    const sessionMessage = poseidon4([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 = jwkToPublicKeyBytes(devicePublicKey)
+    return {
+        current_time: String(request.currentTime),
+        challenge: String(challenge),
+        audience: String(audience),
+        required_programme_hash: String(programmeHash(request.programme)),
+        required_country_code: String(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/src/profile.ts

@@ -0,0 +1,133 @@
+import { ApprovalCredentialClaims, ApprovalScope, Hex32, Jwk, SdJwtIssueParams, StatusClaim } from "./types"
+import { buildStatusClaim } from "./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.
+ */
+
+export const APPROVAL_CREDENTIAL_VCT = "urn:cn:credential:approval:v1"
+
+/** Only the two approvalScope members are disclosable; everything else is plain. */
+export const DISCLOSURE_FRAME = {
+    approvalScope: { _sd: ["programme", "country"] }
+} as const
+
+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}$/
+
+export function networkIdToUrn(id: Hex32): string {
+    const normalized = id.toLowerCase() as Hex32
+    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)}`
+}
+
+export function urnToNetworkId(urn: string): Hex32 | null {
+    return NETWORK_URN_RE.test(urn) ? (`0x${urn.slice("urn:cn:network:".length)}` as Hex32) : null
+}
+
+/** Assembles the full signed payload; the disclosure frame is applied at issue time. */
+export function buildPayload(params: SdJwtIssueParams, jti: string): ApprovalCredentialClaims {
+    return {
+        vct: APPROVAL_CREDENTIAL_VCT,
+        iss: networkIdToUrn(params.issuerNetworkId),
+        sub: networkIdToUrn(params.subjectNetworkId),
+        jti,
+        nbf: params.validFrom,
+        exp: params.validUntil,
+        cnf: { jwk: params.confirmationKey },
+        status: buildStatusClaim(params.revocation.commitment, params.revocationRegistry),
+        approvalScope: { ...params.approvalScope }
+    }
+}
+
+type ClaimsCheck = { ok: true; claims: ApprovalCredentialClaims } | { ok: false; message: string }
+
+const ALLOWED_TOP_LEVEL = new Set(["vct", "iss", "sub", "jti", "nbf", "exp", "cnf", "status", "approvalScope"])
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+function isJwk(value: unknown): value is Jwk {
+    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: unknown): value is StatusClaim {
+    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: unknown): value is ApprovalScope {
+    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).
+ */
+export function validateClaims(payload: unknown): ClaimsCheck {
+    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 !== 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 as unknown as ApprovalCredentialClaims }
+}

package/src/registry-client.ts

@@ -0,0 +1,37 @@
+import { createPublicClient, http, PublicClient } from "viem"
+import { Hex32 } from "./types"
+
+const REGISTRY_ABI = [
+    {
+        type: "function",
+        name: "isApproved",
+        stateMutability: "view",
+        inputs: [{ name: "memberNetworkId", type: "bytes32" }],
+        outputs: [{ type: "bool" }]
+    }
+] as const
+
+/**
+ * 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 class NetworkMemberRegistryClient {
+    private readonly client: PublicClient
+
+    constructor(
+        private readonly registryAddress: `0x${string}`,
+        rpcUrl: string
+    ) {
+        this.client = createPublicClient({ transport: http(rpcUrl) })
+    }
+
+    async isApprovedNetworkMember(id: Hex32): Promise<boolean> {
+        return this.client.readContract({
+            address: this.registryAddress,
+            abi: REGISTRY_ABI,
+            functionName: "isApproved",
+            args: [id]
+        })
+    }
+}

package/src/resolver.ts

@@ -0,0 +1,62 @@
+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 class InMemoryResolver implements Resolver, RevocationWriter {
+    private readonly approved = new Set<Hex32>()
+    private readonly credentialKeys = new Map<Hex32, Jwk>()
+    private readonly revoked = new Set<string>()
+
+    approveMember(id: Hex32): void {
+        this.approved.add(id)
+    }
+
+    removeMember(id: Hex32): void {
+        this.approved.delete(id)
+    }
+
+    setCredentialPublicKey(id: Hex32, jwk: Jwk): void {
+        this.credentialKeys.set(id, jwk)
+    }
+
+    async isApprovedNetworkMember(id: Hex32): Promise<boolean> {
+        return this.approved.has(id)
+    }
+
+    async getCredentialPublicKey(id: Hex32): Promise<Jwk | null> {
+        return this.credentialKeys.get(id) ?? null
+    }
+
+    async isRevoked(commitment: bigint): Promise<boolean> {
+        return this.revoked.has(commitment.toString())
+    }
+
+    async revoke(commitment: bigint): Promise<void> {
+        this.revoked.add(commitment.toString())
+    }
+}