@reclaimprotocol/client 0.1.29 → 0.1.32

package/src/result.ts

@@ -3,10 +3,10 @@
  *  - {@link verifyResult}: the offline primitive — decrypt + decode + optional
  *    ES256K signature check (caller-supplied key) + `reclaimSessionId` nonce.
  *  - {@link verifyResultFull}: the recommended server-side verification —
- *    resolves a registered issuer, discovers the Verification Client's key
+ *    resolves Builder's trusted issuer, discovers Builder's key
  *    via JWKS, checks
  *    `reclaimSessionId`/`aud` and any legacy `exp`, and passes every exact
- *    legacy proof to the in-package, legacy-compatible `verifyProof` verifier.
+ *    proof to the in-package `verifyRequestProof` verifier.
  *
  * See docs/verification-session.md → "Verification by Consumer".
  */
@@ -14,26 +14,35 @@ import { sha256 } from '@noble/hashes/sha2.js'
 import { decrypt as eciesDecrypt, encrypt as eciesEncrypt } from 'eciesjs'
 import type { components } from './types/openapi.gen.ts'
 import type { DecryptionKey } from './enckeys.ts'
-import { b64url, base64urlToBytes, hexToBytes } from './encoding.ts'
+import {
+	b64url,
+	base64urlToBytes,
+	hexToBytes,
+	stripTrailingSlashes,
+} from './encoding.ts'
 import {
 	fetchReclaimJwks,
 	type Jwk,
 	jwkToUncompressedPublicKey,
 	selectVerificationResultKey,
 } from './jwks.ts'
-import {
-	type LegacyProof,
-	type LegacyVerifyProofOptions,
-	type ProofHashRequirement,
-	verifyProof,
-} from './legacy-proof.ts'
+import { getHashFromProof } from './proof-hash.ts'
 import {
 	type BuilderProofRecipe,
 	proofHashesFromBuilderRecipe,
 } from './proof-recipe.ts'
 import type { TrustedData } from './proof-types.ts'
+import {
+	type ProofHashRequirement,
+	type ReclaimRequestProof,
+	verifyRequestProof,
+	type VerifyRequestProofOptions,
+} from './request-proof.ts'
 import { addressFromUncompressedPubkey, secp } from './secp.ts'
 
+/** Longest `iss` worth comparing. Real issuers are short origins. */
+const MAX_ISSUER_LENGTH = 2048
+
 export interface Jws {
 	payload: string
 	signatures: {
@@ -49,12 +58,10 @@ export interface VerifyResultOptions {
 	signerPublicKey?: string
 	/** The `reclaimSessionId` the consumer expects (the session id they got
 	 *  back at creation). When given, mismatch fails verification. */
-	expectedReclaimSessionId?: string
+	reclaimSessionId?: string
 }
 
 export interface VerifyResultOutcome {
-	valid: boolean
-	reason?: string
 	payload: Record<string, unknown>
 	reclaimSessionId?: string
 }
@@ -161,9 +168,10 @@ export async function decryptCallback(
 	// Otherwise it's an ECIES ciphertext (base64url).
 	if(!privateKey) {
 		throw new Error(
-			'received an encrypted (ECIES) delivery but no decryption credential was '
-				+ 'configured — pass the eth private key (0x-hex): '
-				+ 'results.receive(body, { credential }) or decrypt(body, credential)',
+			'received an encrypted (ECIES) delivery but no org ETH private key was '
+				+ 'provided — pass the 0x-hex private key: '
+				+ 'results.receive(body, { orgEthPrivateKey }) or '
+				+ 'decrypt(body, orgEthPrivateKey)',
 		)
 	}
 
@@ -175,7 +183,7 @@ export async function decryptCallback(
  * Sign a verification result as a flattened JWS (JOSE ES256K = ECDSA/secp256k1
  * over SHA-256 of the `<protected>.<payload>` signing input — a single hash).
  * `kid` is the signer's ETH address (published via JWKS); `iss` is the issuer
- * URL. Used by the Verification Client to sign results before encrypting them.
+ * URL. Used by Builder to sign results before encrypting them.
  */
 export function signResultJws(
 	privateKeyHex: string,
@@ -219,6 +227,13 @@ export function verifyJwsSignature(jws: Jws, signerPublicKey: string): boolean {
 	const pub = hexToBytes(signerPublicKey)
 	return jws.signatures.some((s) => {
 		try {
+			const header = JSON.parse(
+				new TextDecoder().decode(base64urlToBytes(s.protected)),
+			) as Record<string, unknown>
+			if(header.alg !== 'ES256K') {
+				return false
+			}
+
 			const signingInput = new TextEncoder().encode(
 				`${s.protected}.${jws.payload}`
 			)
@@ -234,44 +249,27 @@ export function verifyJwsSignature(jws: Jws, signerPublicKey: string): boolean {
 }
 
 export interface VerifyResultFullOptions {
-	/** Builder session id. Alias for `expectedReclaimSessionId`. */
-	sessionId?: string
 	/** The `reclaimSessionId` the consumer expects (mismatch fails). */
-	expectedReclaimSessionId?: string
+	reclaimSessionId?: string
+	/** Optional organization ETH private key used to verify legacy TEE binding.
+	 *  Callers must provide it for each verification; it isn't retained. */
+	orgEthPrivateKey?: string
 	/** The consumer's `orgId`; the result's `aud` must match it. */
 	expectedAud?: string
 	/** Allowlist of trusted attestor ETH addresses (lowercased compared). */
 	attestorAddresses?: string[]
-	/** One explicitly trusted Verification Client issuer. */
-	issuer?: string
-	/** Alias for `issuer`. */
-	trustedIssuer?: string
-	/** Explicitly trusted Verification Client issuers. */
-	issuers?: string[]
-	/** Alias for `issuers`, retained for security-focused callers. */
+	/** Explicitly trusted Builder issuers. */
 	trustedIssuers?: string[]
-	/** Resolve registered issuer URLs for the signed session's client id. */
-	resolveIssuers?: (verificationClientId: string) =>
-		Promise<readonly string[]> | readonly string[]
-	/** Alias for `resolveIssuers`. */
-	issuerResolver?: (verificationClientId: string) =>
-		Promise<readonly string[]> | readonly string[]
-	/** Registered issuer URLs keyed by `verificationClientId`. */
-	issuersByVerificationClientId?: Record<string, string[]>
-	/** Explicit trusted JWKS URL. This value must come from your registry. */
+	/** Explicit trusted Builder JWKS URL. */
 	jwksUrl?: string
-	/** Trusted JWKS URLs keyed by `verificationClientId`. */
-	jwksUrlsByVerificationClientId?: Record<string, string>
-	/** Resolve a registered JWKS URL for the signed session's client id. */
-	resolveJwksUrl?: (verificationClientId: string) =>
-		Promise<string | undefined> | string | undefined
-	/** Legacy-compatible proof validation options applied to all proofs. */
-	proofValidation?: LegacyVerifyProofOptions
-	/** Alias for `proofValidation`. */
-	proofVerification?: LegacyVerifyProofOptions
+	/**
+	 * Proof validation options applied to all proofs.
+	 * `requireSessionBinding` defaults to true when an expected session is set.
+	 */
+	proofValidation?: VerifyRequestProofOptions
 	/** Per-provider overrides for sessions containing different providers. */
-	proofValidationByProviderId?: Record<string, LegacyVerifyProofOptions>
-	/** Legacy-compatible hash requirements, for the common simple case. */
+	proofValidationByProviderId?: Record<string, VerifyRequestProofOptions>
+	/** Hash requirements, for the common simple case. */
 	hashes?: ProofHashRequirement[]
 	/** Resolved Builder recipes, used to derive strict proof hashes offline. */
 	proofRecipes?: BuilderProofRecipe[]
@@ -280,7 +278,8 @@ export interface VerifyResultFullOptions {
 		sessionId: string,
 	) => Promise<{ recipes: BuilderProofRecipe[] }>
 		| { recipes: BuilderProofRecipe[] }
-	/** Override the VC signer key instead of JWKS discovery via header `iss`. */
+	/** Override Builder's signer key instead of JWKS discovery.
+	 *  The header `iss` is otherwise used only after trust checks. */
 	signerPublicKey?: string
 	/** Injectable fetch (for JWKS); defaults to global `fetch`. */
 	fetchImpl?: typeof fetch
@@ -297,10 +296,28 @@ export interface VerifyResultFullOptions {
 export interface ResultProofOutcome {
 	/** Which provider this proof belongs to (results grouped per provider). */
 	providerId?: string
+	/** Exact immutable provider version used to validate this proof. */
+	resolvedVersion?: string
 	requestId?: string
+	/** Exact proof carried by the Builder-signed result. */
+	proof?: ReclaimRequestProof
 	proofValid: boolean
 	reason?: string
+	/** @deprecated Use `attestorAddresses`; retained for compatibility. */
 	attestorAddress?: string
+	/** Every attestor address declared by the proof. */
+	attestorAddresses?: string[]
+	/** Provider hashes derived from this exact proof. */
+	proofHashes?: string[]
+	/** True when the claimant/session TEE attestation was requested and
+	 * verified. */
+	isTeeAttestationVerified?: boolean
+	/** True when the attestor TEE attestation was requested and at least one
+	 *  witness's `attestation_report` verified. False when the check ran but no
+	 *  witness carried a report — the common production shape, where the
+	 *  attestor address and claim signature are still verified. Undefined when
+	 *  the check didn't run. */
+	isAttestorTeeAttestationVerified?: boolean
 	/** Trusted only when `proofValid` is true. */
 	data?: TrustedData
 	/** Provider-supplied data. It isn't cryptographically validated. */
@@ -311,13 +328,19 @@ export interface VerifyResultFullOutcome extends VerifyResultOutcome {
 	proofs?: ResultProofOutcome[]
 }
 
+export interface ResultVerificationFailure extends VerifyResultFullOutcome {
+	reason: string
+}
+
 /**
  * Thrown by {@link verifyResult} / {@link verifyResultFull} (and therefore
  * `reclaim.results.verify`/`receive`) when a result fails verification. Carries
  * the full invalid outcome so callers can inspect it in a `catch`:
  *
  *   try {
- *     const { result } = await reclaim.results.receive(body, { credential })
+ *     const { result } = await reclaim.results.receive(body, {
+ *       orgEthPrivateKey,
+ *     })
  *     // result is verified — use result.payload
  *   } catch (err) {
  *     if (err instanceof ResultVerificationError) {
@@ -332,21 +355,21 @@ export class ResultVerificationError extends Error {
 	readonly reason: string
 	/** The full (invalid) outcome: `payload`, `reclaimSessionId`, and per-proof
 	 *  detail (`proofs`) when verification got that far. */
-	readonly outcome: VerifyResultFullOutcome
+	readonly outcome: ResultVerificationFailure
 
-	constructor(outcome: VerifyResultFullOutcome) {
-		super(`result verification failed: ${outcome.reason ?? 'invalid'}`)
+	constructor(outcome: ResultVerificationFailure) {
+		super(`result verification failed: ${outcome.reason}`)
 		this.name = 'ResultVerificationError'
-		this.reason = outcome.reason ?? 'invalid'
+		this.reason = outcome.reason
 		this.outcome = outcome
 	}
 }
 
 /**
- * Full consumer verification: resolves a trusted, registered issuer before
+ * Full consumer verification: resolves a configured Builder issuer before
  * using JWKS (header `iss`/`kid`), verifies the top-level JWS, checks
  * `reclaimSessionId`/`aud` and any legacy `exp`, then verifies each exact
- * legacy proof.
+ * proof.
  * Network access (JWKS and optional provider resolution) makes this async.
  * Use {@link verifyResult} for the offline primitive.
  */
@@ -357,14 +380,14 @@ export async function verifyResultFull(
 	const payload = decodeJwsPayload(jws)
 	const reclaimSessionId = payload.reclaimSessionId as string | undefined
 	let jwksAttestorAddresses: string[] = []
+	let jwksAttestorImageDigests: string[] = []
 	/** Throw with the full invalid outcome — verification never *returns* an
 	 *  invalid result. */
 	const fail = (
 		reason: string,
-		extra: Partial<VerifyResultFullOutcome> = {},
+		extra: Partial<ResultVerificationFailure> = {},
 	): never => {
 		throw new ResultVerificationError({
-			valid: false,
 			reason,
 			payload,
 			reclaimSessionId,
@@ -372,8 +395,8 @@ export async function verifyResultFull(
 		})
 	}
 
-	// 1. Resolve the VC signer key. Never use the signed header's `iss` as a
-	// network destination until it has matched an explicit or registered issuer.
+	// 1. Resolve Builder's signer key. Never use the signed header's `iss` as a
+	// network destination until it has matched an explicitly trusted issuer.
 	let signerPublicKey = opts.signerPublicKey
 	let header: Record<string, unknown> = {}
 	const sig0 = jws.signatures[0]
@@ -388,16 +411,7 @@ export async function verifyResultFull(
 	}
 
 	if(!signerPublicKey) {
-		const verificationClientId = getVerificationClientId(payload) ?? ''
-		let configuredIssuers: string[]
-		try {
-			configuredIssuers = await resolveTrustedIssuers(
-				opts,
-				verificationClientId,
-			)
-		} catch{
-			return fail('issuer-resolution-failed')
-		}
+		const configuredIssuers = resolveTrustedIssuers(opts)
 
 		if(!configuredIssuers.length) {
 			return fail('issuer-not-configured')
@@ -408,6 +422,12 @@ export async function verifyResultFull(
 			return fail('no-issuer')
 		}
 
+		// Read before the signature is checked, so it is attacker-supplied: a
+		// real issuer is a short origin, never kilobytes.
+		if(iss.length > MAX_ISSUER_LENGTH) {
+			return fail('issuer-not-trusted')
+		}
+
 		const trustedIssuer = configuredIssuers.find((candidate) => (
 			normalizeIssuer(candidate) === normalizeIssuer(iss)
 		))
@@ -417,17 +437,15 @@ export async function verifyResultFull(
 
 		let keys: Jwk[]
 		try {
-			const jwksUrl = await resolveTrustedJwksUrl(
-				opts,
-				verificationClientId,
-			)
 			const registry = await fetchReclaimJwks(
-				jwksUrl
-					?? `${trustedIssuer.replace(/\/+$/, '')}/.well-known/jwks.json`,
+				opts.jwksUrl
+					?? `${stripTrailingSlashes(trustedIssuer)}/.well-known/jwks.json`,
 				opts.fetchImpl,
 			)
 			keys = registry.keys
 			jwksAttestorAddresses = registry['x-reclaim-attestors'] ?? []
+			jwksAttestorImageDigests =
+				registry['x-reclaim-attestor-image-digests'] ?? []
 		} catch{
 			return fail('jwks-fetch-failed')
 		}
@@ -435,7 +453,6 @@ export async function verifyResultFull(
 		const jwk = selectVerificationResultKey(
 			keys,
 			String(header.kid ?? ''),
-			verificationClientId,
 		)
 		if(!jwk) {
 			return fail('signer-key-not-found')
@@ -444,7 +461,14 @@ export async function verifyResultFull(
 		signerPublicKey = jwkToUncompressedPublicKey(jwk)
 	}
 
-	if(!verifyJwsSignature(jws, signerPublicKey)) {
+	if(header.alg !== 'ES256K') {
+		return fail('unsupported-algorithm')
+	}
+
+	if(!sig0 || !verifyJwsSignature({
+		payload: jws.payload,
+		signatures: [sig0],
+	}, signerPublicKey)) {
 		return fail('bad-signature')
 	}
 
@@ -457,8 +481,7 @@ export async function verifyResultFull(
 	}
 
 	// 2. Session binding, audience, and optional legacy result expiry.
-	const expectedResultSessionId = opts.sessionId
-		?? opts.expectedReclaimSessionId
+	const expectedResultSessionId = opts.reclaimSessionId
 	if(expectedResultSessionId && reclaimSessionId !== expectedResultSessionId) {
 		return fail('reclaimSessionId-mismatch')
 	}
@@ -476,7 +499,7 @@ export async function verifyResultFull(
 		return fail('expired')
 	}
 
-	// 3. Verify every exact legacy proof carried by the signed result. The outer
+	// 3. Verify every exact proof carried by the signed result. The outer
 	// envelope groups proofs by provider, but it never changes the proof shape.
 	const providerResults = Array.isArray(payload.results)
 		? (payload.results as Record<string, unknown>[])
@@ -485,7 +508,7 @@ export async function verifyResultFull(
 	const proofGroups: {
 		providerId?: string
 		providerVersion?: string
-		proof: LegacyProof
+		proof: ReclaimRequestProof
 		outcomeIndex: number
 	}[] = []
 	for(const prov of providerResults) {
@@ -500,18 +523,25 @@ export async function verifyResultFull(
 		for(const r of requests) {
 			const requestId =
 				typeof r.request_id === 'string' ? r.request_id : undefined
-			if(!isLegacyProof(r.proof)) {
+			if(!isReclaimRequestProof(r.proof)) {
 				proofs.push({
-					providerId, requestId, proofValid: false, reason: 'proof-missing',
+					providerId,
+					resolvedVersion: providerVersion,
+					requestId,
+					proofValid: false,
+					reason: 'proof-missing',
 				})
 				continue
 			}
 
 			proofs.push({
 				providerId,
+				resolvedVersion: providerVersion,
 				requestId,
+				proof: r.proof,
 				proofValid: true,
 				attestorAddress: r.proof.witnesses[0]?.id,
+				attestorAddresses: r.proof.witnesses.map(({ id }) => id),
 			})
 			proofGroups.push({
 				providerId,
@@ -529,25 +559,63 @@ export async function verifyResultFull(
 
 	if(proofGroups.length) {
 		const expectedSessionId = expectedResultSessionId
-		const configuredProofValidation = opts.proofValidation
-			?? opts.proofVerification
+		const hasTeeBoundProof = proofGroups.some(({ proof }) => (
+			proofHasTeeBinding(proof)
+		))
+		const configuredProofValidation = {
+			...opts.proofValidation,
+			...(opts.orgEthPrivateKey && hasTeeBoundProof
+				? {
+					teeAttestation: {
+						appSecret: opts.orgEthPrivateKey,
+					},
+				}
+				: {}),
+		}
 		const attestorAddresses = [...new Set([
 			...(configuredProofValidation?.attestorAddresses ?? []),
 			...(opts.attestorAddresses ?? []),
 			...jwksAttestorAddresses,
 		])]
+		const configuredAttestorTee =
+			configuredProofValidation?.attestorTeeAttestation
+		const configuredImageDigests =
+			configuredAttestorTee?.expectedImageDigests
+		let expectedImageDigests = jwksAttestorImageDigests
+		if(configuredImageDigests?.length && jwksAttestorImageDigests.length) {
+			const registry = new Set(jwksAttestorImageDigests)
+			expectedImageDigests = [...new Set(configuredImageDigests
+				.map((digest) => digest.trim().toLowerCase())
+				.filter((digest) => registry.has(digest)))]
+			if(!expectedImageDigests.length) {
+				return fail('attestor-image-trust-mismatch', { proofs })
+			}
+		} else if(configuredImageDigests?.length) {
+			expectedImageDigests = configuredImageDigests
+		}
+
+		const attestorTeeAttestation = expectedImageDigests.length
+			? { ...configuredAttestorTee, expectedImageDigests }
+			: configuredAttestorTee
 		const commonValidation = {
 			...configuredProofValidation,
 			...(opts.hashes ? { hashes: opts.hashes } : {}),
 			...(attestorAddresses.length
 				? { attestorAddresses }
 				: {}),
+			...(attestorTeeAttestation
+				? { attestorTeeAttestation }
+				: {}),
 			...(expectedSessionId
-				? { expectedSessionId }
+				? {
+					expectedSessionId,
+					requireSessionBinding:
+						configuredProofValidation?.requireSessionBinding ?? true,
+				}
 				: {}),
 		}
 		if(hasContentValidation(commonValidation)) {
-			await verifyLegacyProofGroup(proofGroups, commonValidation)
+			await verifyRequestProofGroup(proofGroups, commonValidation)
 		} else {
 			await verifyByResolvedRecipes(commonValidation, expectedSessionId)
 		}
@@ -557,21 +625,39 @@ export async function verifyResultFull(
 		return fail('invalid-proof', { proofs })
 	}
 
-	return { valid: true, payload, reclaimSessionId, proofs }
+	return { payload, reclaimSessionId, proofs }
 
-	async function verifyLegacyProofGroup(
+	async function verifyRequestProofGroup(
 		group: typeof proofGroups,
-		validation: LegacyVerifyProofOptions,
+		validation: VerifyRequestProofOptions,
 	) {
-		const legacyOutcome = await verifyProof(
+		const requestProofOutcome = await verifyRequestProof(
 			group.map(({ proof }) => proof),
 			validation,
 		)
-		if(legacyOutcome.valid) {
+		if(requestProofOutcome.valid) {
 			for(const [index, item] of group.entries()) {
-				proofs[item.outcomeIndex].data = legacyOutcome.data?.[index]
-				proofs[item.outcomeIndex].publicData =
-					legacyOutcome.publicData?.[index]
+				const outcome = proofs[item.outcomeIndex]
+				const hashes = resultProofHashes(
+					item.proof,
+					validation.hasNoPii,
+				)
+				if(hashes) {
+					outcome.proofHashes = hashes
+				}
+
+				if(requestProofOutcome.isTeeAttestationVerified !== undefined) {
+					outcome.isTeeAttestationVerified =
+						requestProofOutcome.isTeeAttestationVerified
+				}
+
+				if(requestProofOutcome.isAttestorTeeAttestationVerified !== undefined) {
+					outcome.isAttestorTeeAttestationVerified =
+						requestProofOutcome.isAttestorTeeAttestationVerified
+				}
+
+				outcome.data = requestProofOutcome.data?.[index]
+				outcome.publicData = requestProofOutcome.publicData?.[index]
 			}
 
 			return
@@ -579,12 +665,12 @@ export async function verifyResultFull(
 
 		for(const { outcomeIndex } of group) {
 			proofs[outcomeIndex].proofValid = false
-			proofs[outcomeIndex].reason = legacyOutcome.reason
+			proofs[outcomeIndex].reason = requestProofOutcome.reason
 		}
 	}
 
 	async function verifyByResolvedRecipes(
-		common: LegacyVerifyProofOptions,
+		common: VerifyRequestProofOptions,
 		expectedSessionId: string | undefined,
 	) {
 		let recipes = opts.proofRecipes
@@ -611,7 +697,7 @@ export async function verifyResultFull(
 	async function verifyResolvedGroup(
 		group: typeof proofGroups,
 		recipes: BuilderProofRecipe[] | undefined,
-		common: LegacyVerifyProofOptions,
+		common: VerifyRequestProofOptions,
 	) {
 		const providerId = group[0]?.providerId
 		const providerVersion = group[0]?.providerVersion
@@ -635,7 +721,7 @@ export async function verifyResultFull(
 			}
 		}
 
-		await verifyLegacyProofGroup(group, {
+		const validation = {
 			...common,
 			...(recipe
 				? { hashes }
@@ -643,7 +729,15 @@ export async function verifyResultFull(
 					? { providerId, providerVersion }
 					: {}),
 			...providerValidation,
-		})
+			...(common.expectedSessionId
+				? {
+					sessionId: common.sessionId,
+					expectedSessionId: common.expectedSessionId,
+					requireSessionBinding: common.requireSessionBinding,
+				}
+				: {}),
+		}
+		await verifyRequestProofGroup(group, validation)
 	}
 
 	function markInvalid(group: typeof proofGroups, reason: string) {
@@ -654,7 +748,43 @@ export async function verifyResultFull(
 	}
 }
 
-function hasContentValidation(config: LegacyVerifyProofOptions): boolean {
+/** Whether a proof declares the session TEE nonce that the org key verifies. */
+function proofHasTeeBinding(proof: ReclaimRequestProof) {
+	// A `confidential-space` witness carries the attestation itself, so the
+	// proof is TEE-bound even before the context is read. Triggering on it too
+	// means a proof that ships the evidence can't skip the check by omitting
+	// `attestationNonce` — `verifyTeeAttestation` needs that nonce and fails
+	// loudly without it, which is the right outcome.
+	const hasTeeWitness = (proof.witnesses ?? []).some((witness) => (
+		witness.claimAttestation?.type === 'confidential-space'
+		&& !!witness.claimAttestation.tee_attestation
+	))
+	if(hasTeeWitness) {
+		return true
+	}
+
+	try {
+		const context = JSON.parse(proof.claimData.context)
+		return context && typeof context === 'object'
+			&& typeof context.attestationNonce === 'string'
+			&& context.attestationNonce.length > 0
+	} catch{
+		return false
+	}
+}
+
+function resultProofHashes(
+	proof: ReclaimRequestProof,
+	hasNoPii: true | undefined,
+) {
+	try {
+		return getHashFromProof(proof, hasNoPii)
+	} catch{
+		return undefined
+	}
+}
+
+function hasContentValidation(config: VerifyRequestProofOptions): boolean {
 	return Boolean(
 		config.hashes
 		|| config.providerId
@@ -680,7 +810,7 @@ function recipeGroupsMatch(
 		&& [...groups.keys()].every((key) => expected.has(key))
 }
 
-function isLegacyProof(value: unknown): value is LegacyProof {
+function isReclaimRequestProof(value: unknown): value is ReclaimRequestProof {
 	if(!value || typeof value !== 'object' || Array.isArray(value)) {
 		return false
 	}
@@ -705,74 +835,11 @@ function getVerificationStatus(payload: Record<string, unknown>) {
 }
 
 function normalizeIssuer(issuer: string): string {
-	return issuer.trim().replace(/\/+$/, '').toLowerCase()
+	return stripTrailingSlashes(issuer.trim()).toLowerCase()
 }
 
-function getVerificationClientId(
-	payload: Record<string, unknown>,
-): string | undefined {
-	if(typeof payload.verificationClientId === 'string') {
-		return payload.verificationClientId
-	}
-
-	if(typeof payload.verification_client_id === 'string') {
-		return payload.verification_client_id
-	}
-
-	const session = payload.verification_session
-	if(!session || typeof session !== 'object' || Array.isArray(session)) {
-		return undefined
-	}
-
-	const sessionRecord = session as Record<string, unknown>
-	const id = sessionRecord.verificationClientId
-		?? sessionRecord.verification_client_id
-	return typeof id === 'string' ? id : undefined
-}
-
-async function resolveTrustedIssuers(
-	opts: VerifyResultFullOptions,
-	verificationClientId: string | undefined,
-): Promise<string[]> {
-	const explicit = [
-		opts.issuer,
-		opts.trustedIssuer,
-		...(opts.issuers ?? []),
-		...(opts.trustedIssuers ?? []),
-	].filter((issuer): issuer is string => typeof issuer === 'string')
-	if(explicit.length) {
-		return [...new Set(explicit.map(normalizeIssuer))]
-	}
-
-	if(!verificationClientId) {
-		return []
-	}
-
-	const registered =
-		opts.issuersByVerificationClientId?.[verificationClientId] ?? []
-	const resolve = opts.resolveIssuers ?? opts.issuerResolver
-	const resolved = resolve
-		? await resolve(verificationClientId)
-		: []
-	return [...new Set([...registered, ...resolved].map(normalizeIssuer))]
-}
-
-async function resolveTrustedJwksUrl(
-	opts: VerifyResultFullOptions,
-	verificationClientId: string | undefined,
-): Promise<string | undefined> {
-	if(opts.jwksUrl) {
-		return opts.jwksUrl
-	}
-
-	if(!verificationClientId) {
-		return undefined
-	}
-
-	const registered = opts.jwksUrlsByVerificationClientId?.[
-		verificationClientId
-	]
-	return registered ?? await opts.resolveJwksUrl?.(verificationClientId)
+function resolveTrustedIssuers(opts: VerifyResultFullOptions): string[] {
+	return [...new Set((opts.trustedIssuers ?? []).map(normalizeIssuer))]
 }
 
 /** Decrypt-and-verify in one step. */
@@ -785,21 +852,20 @@ export function verifyResult(
 
 	if(opts.signerPublicKey && !verifyJwsSignature(jws, opts.signerPublicKey)) {
 		throw new ResultVerificationError({
-			valid: false, reason: 'bad-signature', payload, reclaimSessionId,
+			reason: 'bad-signature', payload, reclaimSessionId,
 		})
 	}
 
 	if(
-		opts.expectedReclaimSessionId &&
-		reclaimSessionId !== opts.expectedReclaimSessionId
+		opts.reclaimSessionId &&
+		reclaimSessionId !== opts.reclaimSessionId
 	) {
 		throw new ResultVerificationError({
-			valid: false,
 			reason: 'reclaimSessionId-mismatch',
 			payload,
 			reclaimSessionId,
 		})
 	}
 
-	return { valid: true, payload, reclaimSessionId }
+	return { payload, reclaimSessionId }
 }