@coordination-network/credential 0.0.1 → 0.1.0

package/src/verify.ts

@@ -1,118 +0,0 @@
-import { SDJwtVcInstance } from "@sd-jwt/sd-jwt-vc"
-import { base64urlToBytes, createSdJwtVerifier, sdJwtHasher } from "./crypto"
-import { urnToNetworkId, validateClaims } from "./profile"
-import { Resolver } from "./resolver"
-import { ApprovalCredentialClaims, Hex32, Jwk, VerifyErrorCode, VerifyResult } from "./types"
-
-export interface VerifyOptions {
-    /** Verification time, unix seconds. Defaults to now. */
-    currentDate?: number
-}
-
-const fail = (code: VerifyErrorCode, message: string): VerifyResult => ({ 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: string,
-    resolver: Resolver,
-    now: number,
-    verifyWithLibrary: (issuerJwk: Jwk, clampedNow: number) => Promise<Record<string, unknown>>
-): Promise<{ result: VerifyResult; issuerId?: Hex32 }> {
-    let payload: Record<string, unknown>
-    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(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" ? 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: Record<string, unknown>
-    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 = validateClaims(reconstructed)
-    if (!checked.ok) {
-        return { result: fail("MALFORMED", checked.message), issuerId }
-    }
-    const claims: ApprovalCredentialClaims = 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.
- */
-export async function verifySdJwtCredential(
-    token: string,
-    resolver: Resolver,
-    options?: VerifyOptions
-): Promise<VerifyResult> {
-    const now = options?.currentDate ?? Math.floor(Date.now() / 1000)
-    const { result } = await runPipeline(token, resolver, now, async (issuerJwk, clampedNow) => {
-        const sdjwt = new SDJwtVcInstance({
-            verifier: createSdJwtVerifier(issuerJwk),
-            hasher: sdJwtHasher,
-            hashAlg: "sha-256"
-        })
-        const { payload } = await sdjwt.verify(token, { currentDate: clampedNow })
-        return payload
-    })
-    return result
-}
-
-export { runPipeline }