@reclaimprotocol/client 0.1.28 → 0.1.31

package/lib/result.d.ts

@@ -1,9 +1,9 @@
 import type { components } from './types/openapi.gen.ts';
 import type { DecryptionKey } from './enckeys.ts';
 import { type Jwk } from './jwks.ts';
-import { type LegacyVerifyProofOptions, type ProofHashRequirement } from './legacy-proof.ts';
 import { type BuilderProofRecipe } from './proof-recipe.ts';
 import type { TrustedData } from './proof-types.ts';
+import { type ProofHashRequirement, type ReclaimRequestProof, type VerifyRequestProofOptions } from './request-proof.ts';
 export interface Jws {
     payload: string;
     signatures: {
@@ -18,11 +18,9 @@ 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;
 }
@@ -69,7 +67,7 @@ export declare function decryptCallback(privateKey: DecryptionKey | undefined, b
  * 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 declare function signResultJws(privateKeyHex: string, payload: Record<string, unknown>, iss: string): Jws;
 /** Decode the JWS payload (base64url JSON). */
@@ -80,41 +78,27 @@ export declare function decodeJwsPayload(jws: Jws): Record<string, unknown>;
  */
 export declare 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[];
@@ -124,7 +108,8 @@ export interface VerifyResultFullOptions {
     }> | {
         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;
@@ -140,10 +125,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. */
@@ -152,13 +155,18 @@ export interface ResultProofOutcome {
 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) {
@@ -173,14 +181,14 @@ export declare 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;
-    constructor(outcome: VerifyResultFullOutcome);
+    readonly outcome: ResultVerificationFailure;
+    constructor(outcome: ResultVerificationFailure);
 }
 /**
- * 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.
  */

package/lib/result.js

@@ -3,20 +3,23 @@
  *  - {@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".
  */
 import { sha256 } from '@noble/hashes/sha2.js';
 import { decrypt as eciesDecrypt, encrypt as eciesEncrypt } from 'eciesjs';
-import { b64url, base64urlToBytes, hexToBytes } from "./encoding.js";
+import { b64url, base64urlToBytes, hexToBytes, stripTrailingSlashes, } from "./encoding.js";
 import { fetchReclaimJwks, jwkToUncompressedPublicKey, selectVerificationResultKey, } from "./jwks.js";
-import { verifyProof, } from "./legacy-proof.js";
+import { getHashFromProof } from "./proof-hash.js";
 import { proofHashesFromBuilderRecipe, } from "./proof-recipe.js";
+import { verifyRequestProof, } from "./request-proof.js";
 import { addressFromUncompressedPubkey, secp } from "./secp.js";
+/** Longest `iss` worth comparing. Real issuers are short origins. */
+const MAX_ISSUER_LENGTH = 2048;
 /**
  * ECIES-encrypt `plaintext` for the holder of `publicJwk` (the org's secp256k1
  * **eth** public JWK, `{kty:'EC', crv:'secp256k1', x, y}`) — `eciesjs` defaults
@@ -79,9 +82,10 @@ export async function decryptCallback(privateKey, body) {
     }
     // 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)');
+        throw new Error('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)');
     }
     const plaintext = eciesDecrypt(privateKey, base64urlToBytes(trimmed));
     return JSON.parse(new TextDecoder().decode(plaintext));
@@ -90,7 +94,7 @@ export async function decryptCallback(privateKey, body) {
  * 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, payload, iss) {
     const priv = hexToBytes(privateKeyHex);
@@ -122,6 +126,10 @@ export function verifyJwsSignature(jws, signerPublicKey) {
     const pub = hexToBytes(signerPublicKey);
     return jws.signatures.some((s) => {
         try {
+            const header = JSON.parse(new TextDecoder().decode(base64urlToBytes(s.protected)));
+            if (header.alg !== 'ES256K') {
+                return false;
+            }
             const signingInput = new TextEncoder().encode(`${s.protected}.${jws.payload}`);
             const digest = sha256(signingInput);
             const sig = base64urlToBytes(s.signature);
@@ -140,7 +148,9 @@ export function verifyJwsSignature(jws, signerPublicKey) {
  * 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) {
@@ -151,17 +161,17 @@ export function verifyJwsSignature(jws, signerPublicKey) {
  */
 export class ResultVerificationError extends Error {
     constructor(outcome) {
-        super(`result verification failed: ${outcome.reason ?? 'invalid'}`);
+        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.
  */
@@ -169,19 +179,19 @@ export async function verifyResultFull(jws, opts = {}) {
     const payload = decodeJwsPayload(jws);
     const reclaimSessionId = payload.reclaimSessionId;
     let jwksAttestorAddresses = [];
+    let jwksAttestorImageDigests = [];
     /** Throw with the full invalid outcome — verification never *returns* an
      *  invalid result. */
     const fail = (reason, extra = {}) => {
         throw new ResultVerificationError({
-            valid: false,
             reason,
             payload,
             reclaimSessionId,
             ...extra,
         });
     };
-    // 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 = {};
     const sig0 = jws.signatures[0];
@@ -194,14 +204,7 @@ export async function verifyResultFull(jws, opts = {}) {
         }
     }
     if (!signerPublicKey) {
-        const verificationClientId = getVerificationClientId(payload) ?? '';
-        let configuredIssuers;
-        try {
-            configuredIssuers = await resolveTrustedIssuers(opts, verificationClientId);
-        }
-        catch {
-            return fail('issuer-resolution-failed');
-        }
+        const configuredIssuers = resolveTrustedIssuers(opts);
         if (!configuredIssuers.length) {
             return fail('issuer-not-configured');
         }
@@ -209,28 +212,40 @@ export async function verifyResultFull(jws, opts = {}) {
         if (!iss) {
             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)));
         if (!trustedIssuer) {
             return fail('issuer-not-trusted');
         }
         let keys;
         try {
-            const jwksUrl = await resolveTrustedJwksUrl(opts, verificationClientId);
-            const registry = await fetchReclaimJwks(jwksUrl
-                ?? `${trustedIssuer.replace(/\/+$/, '')}/.well-known/jwks.json`, opts.fetchImpl);
+            const registry = await fetchReclaimJwks(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');
         }
-        const jwk = selectVerificationResultKey(keys, String(header.kid ?? ''), verificationClientId);
+        const jwk = selectVerificationResultKey(keys, String(header.kid ?? ''));
         if (!jwk) {
             return fail('signer-key-not-found');
         }
         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');
     }
     if (typeof payload.iss === 'string'
@@ -239,8 +254,7 @@ export async function verifyResultFull(jws, opts = {}) {
         return fail('issuer-mismatch');
     }
     // 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');
     }
@@ -253,7 +267,7 @@ export async function verifyResultFull(jws, opts = {}) {
         && payload.exp < now) {
         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
@@ -270,17 +284,24 @@ export async function verifyResultFull(jws, opts = {}) {
             : [];
         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,
@@ -296,25 +317,58 @@ export async function verifyResultFull(jws, opts = {}) {
     }
     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);
@@ -323,20 +377,32 @@ export async function verifyResultFull(jws, opts = {}) {
     if (!proofs.every((p) => p.proofValid)) {
         return fail('invalid-proof', { proofs });
     }
-    return { valid: true, payload, reclaimSessionId, proofs };
-    async function verifyLegacyProofGroup(group, validation) {
-        const legacyOutcome = await verifyProof(group.map(({ proof }) => proof), validation);
-        if (legacyOutcome.valid) {
+    return { payload, reclaimSessionId, proofs };
+    async function verifyRequestProofGroup(group, validation) {
+        const requestProofOutcome = await verifyRequestProof(group.map(({ proof }) => proof), validation);
+        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;
         }
         for (const { outcomeIndex } of group) {
             proofs[outcomeIndex].proofValid = false;
-            proofs[outcomeIndex].reason = legacyOutcome.reason;
+            proofs[outcomeIndex].reason = requestProofOutcome.reason;
         }
     }
     async function verifyByResolvedRecipes(common, expectedSessionId) {
@@ -377,7 +443,7 @@ export async function verifyResultFull(jws, opts = {}) {
                 return;
             }
         }
-        await verifyLegacyProofGroup(group, {
+        const validation = {
             ...common,
             ...(recipe
                 ? { hashes }
@@ -385,7 +451,15 @@ export async function verifyResultFull(jws, opts = {}) {
                     ? { providerId, providerVersion }
                     : {}),
             ...providerValidation,
-        });
+            ...(common.expectedSessionId
+                ? {
+                    sessionId: common.sessionId,
+                    expectedSessionId: common.expectedSessionId,
+                    requireSessionBinding: common.requireSessionBinding,
+                }
+                : {}),
+        };
+        await verifyRequestProofGroup(group, validation);
     }
     function markInvalid(group, reason) {
         for (const { outcomeIndex } of group) {
@@ -394,6 +468,36 @@ export async function verifyResultFull(jws, opts = {}) {
         }
     }
 }
+/** Whether a proof declares the session TEE nonce that the org key verifies. */
+function proofHasTeeBinding(proof) {
+    // 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, hasNoPii) {
+    try {
+        return getHashFromProof(proof, hasNoPii);
+    }
+    catch {
+        return undefined;
+    }
+}
 function hasContentValidation(config) {
     return Boolean(config.hashes
         || config.providerId
@@ -407,7 +511,7 @@ function recipeGroupsMatch(recipes, groups) {
     return expected.size === groups.size
         && [...groups.keys()].every((key) => expected.has(key));
 }
-function isLegacyProof(value) {
+function isReclaimRequestProof(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
         return false;
     }
@@ -428,53 +532,10 @@ function getVerificationStatus(payload) {
     return typeof status === 'string' ? status : undefined;
 }
 function normalizeIssuer(issuer) {
-    return issuer.trim().replace(/\/+$/, '').toLowerCase();
+    return stripTrailingSlashes(issuer.trim()).toLowerCase();
 }
-function getVerificationClientId(payload) {
-    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;
-    const id = sessionRecord.verificationClientId
-        ?? sessionRecord.verification_client_id;
-    return typeof id === 'string' ? id : undefined;
-}
-async function resolveTrustedIssuers(opts, verificationClientId) {
-    const explicit = [
-        opts.issuer,
-        opts.trustedIssuer,
-        ...(opts.issuers ?? []),
-        ...(opts.trustedIssuers ?? []),
-    ].filter((issuer) => 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, verificationClientId) {
-    if (opts.jwksUrl) {
-        return opts.jwksUrl;
-    }
-    if (!verificationClientId) {
-        return undefined;
-    }
-    const registered = opts.jwksUrlsByVerificationClientId?.[verificationClientId];
-    return registered ?? await opts.resolveJwksUrl?.(verificationClientId);
+function resolveTrustedIssuers(opts) {
+    return [...new Set((opts.trustedIssuers ?? []).map(normalizeIssuer))];
 }
 /** Decrypt-and-verify in one step. */
 export function verifyResult(jws, opts = {}) {
@@ -482,17 +543,16 @@ export function verifyResult(jws, opts = {}) {
     const reclaimSessionId = payload.reclaimSessionId;
     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) {
+    if (opts.reclaimSessionId &&
+        reclaimSessionId !== opts.reclaimSessionId) {
         throw new ResultVerificationError({
-            valid: false,
             reason: 'reclaimSessionId-mismatch',
             payload,
             reclaimSessionId,
         });
     }
-    return { valid: true, payload, reclaimSessionId };
+    return { payload, reclaimSessionId };
 }