@reclaimprotocol/client 0.1.27 → 0.1.28

package/lib/errors.js

@@ -1,22 +1,105 @@
-import { Boom } from '@hapi/boom';
 import { PROBLEM_CONTENT_TYPE } from "./consts.js";
-// Reads an `application/problem+json` response and throws a Boom-style
-// error. Falls back to status-only mapping when the body isn't a problem doc.
-export async function throwProblemError(res) {
+/** Returns whether a thrown value is a Builder {@link ProblemError}. */
+export function isProblemError(error) {
+    if (!(error instanceof Error) || !('isBoom' in error)) {
+        return false;
+    }
+    if (error.isBoom !== true
+        || !('isServer' in error)
+        || typeof error.isServer !== 'boolean'
+        || !('data' in error)
+        || !('output' in error)) {
+        return false;
+    }
+    return isProblemDetails(error.data)
+        && isProblemErrorOutput(error.output);
+}
+/** Returns whether a value follows the RFC 9457 problem-details schema. */
+export function isProblemDetails(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return isOptionalString(value.type)
+        && isOptionalString(value.title)
+        && isOptionalStatus(value.status)
+        && isOptionalString(value.detail)
+        && isOptionalString(value.instance)
+        && isOptionalString(value.event)
+        && isOptionalString(value.sessionId);
+}
+/** Reads an RFC 9457 response, with a status-only fallback for other bodies. */
+export async function readProblemDetails(res) {
     const contentType = res.headers.get('Content-Type') || '';
-    let problem;
     if (contentType.includes(PROBLEM_CONTENT_TYPE)) {
-        problem = (await res.json());
+        try {
+            const value = await res.json();
+            if (isProblemDetails(value)) {
+                return {
+                    ...value,
+                    type: value.type || 'about:blank',
+                    title: value.title || res.statusText,
+                    status: value.status || res.status,
+                };
+            }
+        }
+        catch {
+            // Fall back to the HTTP status when the problem body isn't valid JSON.
+        }
     }
-    else {
-        problem = {
-            type: 'about:blank',
-            status: res.status,
-            title: res.statusText,
-        };
-    }
-    throw new Boom(problem.title, {
-        statusCode: res.status,
+    return {
+        type: 'about:blank',
+        status: res.status,
+        title: res.statusText,
+    };
+}
+/** Throws a browser-safe, Boom-compatible RFC 9457 error. */
+export async function throwProblemError(res) {
+    const problem = await readProblemDetails(res);
+    const title = problem.title || res.statusText || 'Request failed';
+    const fields = {
+        isBoom: true,
+        isServer: res.status >= 500,
         data: problem,
-    });
+        output: {
+            statusCode: res.status,
+            headers: { 'content-type': PROBLEM_CONTENT_TYPE },
+            payload: {
+                ...problem,
+                statusCode: res.status,
+                error: title,
+                message: problem.detail || title,
+            },
+        },
+    };
+    const error = Object.assign(new Error(title), fields);
+    error.name = 'ProblemError';
+    throw error;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isProblemErrorOutput(value) {
+    if (!isRecord(value) || !isRecord(value.payload)) {
+        return false;
+    }
+    return typeof value.statusCode === 'number'
+        && isStringRecord(value.headers)
+        && isProblemDetails(value.payload)
+        && typeof value.payload.statusCode === 'number'
+        && typeof value.payload.error === 'string'
+        && typeof value.payload.message === 'string';
+}
+function isStringRecord(value) {
+    return isRecord(value)
+        && Object.values(value).every(item => typeof item === 'string');
+}
+function isOptionalString(value) {
+    return value === undefined || typeof value === 'string';
+}
+function isOptionalStatus(value) {
+    return value === undefined
+        || typeof value === 'number'
+            && Number.isInteger(value)
+            && value >= 100
+            && value <= 599;
 }

package/lib/index.d.ts

@@ -1,8 +1,5 @@
-export * from './client.ts';
-export type * from './client.ts';
-export { throwProblemError } from './errors.ts';
-export type { ProblemDetails, ProblemError } from './errors.ts';
-export { DEFAULT_BASE_URL, PROBLEM_CONTENT_TYPE, USER_AGENT } from './consts.ts';
+export * from './api.ts';
+export { USER_AGENT } from './consts.ts';
 export { addressFromPublicKey, deriveFromPrivateKey, type EthKeypair, generateKeypair, } from './keypair.ts';
 export { canonicalJson } from './canonical.ts';
 export { b64url, base64urlToBytes, bytesToHex, hexToBytes, } from './encoding.ts';
@@ -10,6 +7,11 @@ export { addressFromUncompressedPubkey, secp, } from './secp.ts';
 export { eip191Digest, signEip191 } from './eip191.ts';
 export { type CallbackBody, decodeJwsPayload, decryptCallback, type DeliveryEnvelope, encryptForEthPublicKey, type Jws, ResultVerificationError, type ResultProofOutcome, signResultJws, verifyJwsSignature, verifyResult, verifyResultFull, type VerifyResultFullOptions, type VerifyResultFullOutcome, type VerifyResultOptions, type VerifyResultOutcome, } from './result.ts';
 export { type DecryptionKey, type DecryptionKeyInput, generateEthKeypair, type GeneratedEthKeypair, loadDecryptionKey, pubkeyJwkToEthAddress, uncompressedPubkeyToJwk, } from './enckeys.ts';
-export { createReclaim, type CreateSessionInput, type Reclaim, type ReclaimConfig, type ReceiveOptions, type ReceivedDelivery, type RegisterCallbackInput, type SetKeypairInput, TERMINAL_EVENTS, } from './reclaim.ts';
-export { fetchJwks, type Jwk, jwksFromPrivateKey, jwkToUncompressedPublicKey, selectKey, } from './jwks.ts';
+export { createReclaim, type CreateSessionInput, type CreateSessionTeeAttestation, type Reclaim, type ReclaimConfig, type ReceiveOptions, type ReceivedDelivery, type RegisterCallbackInput, type SetKeypairInput, TERMINAL_EVENTS, } from './reclaim.ts';
+export { fetchJwks, fetchJwksUrl, fetchReclaimJwks, type Jwk, jwksFromPrivateKey, jwkToUncompressedPublicKey, type ReclaimJwks, selectKey, selectVerificationResultKey, trustedAttestorAddresses, validateAttestorAddresses, } from './jwks.ts';
 export { type NestedProofOutcome, verifyNestedProof, } from './attestor-proof.ts';
+export { type LegacyProof, type LegacyProofOutcome, type LegacyVerifyProofOptions, type ProofHashRequirement, proofHashes, verifyProof, } from './legacy-proof.ts';
+export { type BuilderProofRecipe, proofHashesFromBuilderRecipe, } from './proof-recipe.ts';
+export { getHashFromProof, hashProofClaimParams, hashRequestSpec, type HttpProofParams, type ProofRequestSpec, } from './proof-hash.ts';
+export { builderTeeBindingPayload, BUILDER_TEE_BINDING_DOMAIN, createBuilderTeeBinding, createLegacyTeeNonceContext, deriveLegacySignatureTeeNonce, deriveLegacyTeeNonce, LEGACY_TEE_ATTESTATION_VERSION, LEGACY_TEE_NONCE_DOMAIN, legacyApplicationIdFromPrivateKey, signBuilderTeeBinding, type BuilderTeeBinding, type BuilderTeeBindingPayload, type LegacyTeeNonceContext, type LegacyTeeNonceData, type LegacyTeeNonceMode, } from './tee-binding.ts';
+export { KNOWN_VERIFICATION_CLIENTS, type KnownVerificationClientName, type KnownVerificationClientUrlMap, } from './verification-clients.ts';

package/lib/index.js

@@ -1,6 +1,5 @@
-export * from "./client.js";
-export { throwProblemError } from "./errors.js";
-export { DEFAULT_BASE_URL, PROBLEM_CONTENT_TYPE, USER_AGENT } from "./consts.js";
+export * from "./api.js";
+export { USER_AGENT } from "./consts.js";
 export { addressFromPublicKey, deriveFromPrivateKey, generateKeypair, } from "./keypair.js";
 export { canonicalJson } from "./canonical.js";
 export { b64url, base64urlToBytes, bytesToHex, hexToBytes, } from "./encoding.js";
@@ -9,5 +8,10 @@ export { eip191Digest, signEip191 } from "./eip191.js";
 export { decodeJwsPayload, decryptCallback, encryptForEthPublicKey, ResultVerificationError, signResultJws, verifyJwsSignature, verifyResult, verifyResultFull, } from "./result.js";
 export { generateEthKeypair, loadDecryptionKey, pubkeyJwkToEthAddress, uncompressedPubkeyToJwk, } from "./enckeys.js";
 export { createReclaim, TERMINAL_EVENTS, } from "./reclaim.js";
-export { fetchJwks, jwksFromPrivateKey, jwkToUncompressedPublicKey, selectKey, } from "./jwks.js";
+export { fetchJwks, fetchJwksUrl, fetchReclaimJwks, jwksFromPrivateKey, jwkToUncompressedPublicKey, selectKey, selectVerificationResultKey, trustedAttestorAddresses, validateAttestorAddresses, } from "./jwks.js";
 export { verifyNestedProof, } from "./attestor-proof.js";
+export { proofHashes, verifyProof, } from "./legacy-proof.js";
+export { proofHashesFromBuilderRecipe, } from "./proof-recipe.js";
+export { getHashFromProof, hashProofClaimParams, hashRequestSpec, } from "./proof-hash.js";
+export { builderTeeBindingPayload, BUILDER_TEE_BINDING_DOMAIN, createBuilderTeeBinding, createLegacyTeeNonceContext, deriveLegacySignatureTeeNonce, deriveLegacyTeeNonce, LEGACY_TEE_ATTESTATION_VERSION, LEGACY_TEE_NONCE_DOMAIN, legacyApplicationIdFromPrivateKey, signBuilderTeeBinding, } from "./tee-binding.js";
+export { KNOWN_VERIFICATION_CLIENTS, } from "./verification-clients.js";

package/lib/jwks.d.ts

@@ -6,19 +6,43 @@ export interface Jwk {
     kid?: string;
     alg?: string;
     use?: string;
+    key_ops?: string[];
+    /** Restricts how Builder consumers may use this key. */
+    'x-reclaim-purpose'?: 'verification-result' | 'attestor-proof';
+    /** Verification Client that owns a result-signing key. */
+    'x-reclaim-verification-client-id'?: string;
+    /** Verification Clients that share a built-in result-signing key. */
+    'x-reclaim-verification-client-ids'?: string[];
+    /** Attestor proofs use EIP-191 rather than JOSE ES256K. */
+    'x-reclaim-signature-scheme'?: 'EIP-191';
+}
+export interface ReclaimJwks {
+    keys: Jwk[];
+    /** Trusted EIP-191 attestor signer addresses (public-key hashes). */
+    'x-reclaim-attestors'?: string[];
 }
 /**
  * Build the JWK set for an ES256K signing key (the Verification Client's
  * result-signing key). `kid` is the key's ETH address; `x`/`y` are the
  * uncompressed public-key coordinates. Empty set when no key is configured.
  */
-export declare function jwksFromPrivateKey(privateKeyHex?: string): {
+export declare function jwksFromPrivateKey(privateKeyHex?: string, metadata?: Pick<Jwk, 'x-reclaim-purpose' | 'x-reclaim-verification-client-id' | 'x-reclaim-verification-client-ids'>): {
     keys: Jwk[];
 };
 /** Fetch the JWK set published at `<iss>/.well-known/jwks.json`. */
 export declare function fetchJwks(iss: string, fetchImpl?: typeof fetch): Promise<Jwk[]>;
+/** Fetch a JWK set from an explicitly trusted registry URL. */
+export declare function fetchJwksUrl(url: string, fetchImpl?: typeof fetch): Promise<Jwk[]>;
+/** Fetch Builder's JWKS plus its namespaced attestor trust registry. */
+export declare function fetchReclaimJwks(url: string, fetchImpl?: typeof fetch): Promise<ReclaimJwks>;
 /** Find the key matching `kid` (case-insensitive — kids are ETH addresses). */
 export declare function selectKey(keys: Jwk[], kid: string): Jwk | undefined;
+/** Select a result key and enforce its Verification Client ownership. */
+export declare function selectVerificationResultKey(keys: Jwk[], kid: string, verificationClientId: string): Jwk | undefined;
+/** Return ETH addresses from keys explicitly registered for attestor proofs. */
+export declare function trustedAttestorAddresses(keys: Jwk[]): string[];
+/** Validate and normalize the JWKS address-only trust extension. */
+export declare function validateAttestorAddresses(addresses: string[]): string[];
 /**
  * Reconstruct the uncompressed secp256k1 public key (`0x04` + X + Y) from an
  * EC JWK's base64url `x`/`y` coordinates, for signature verification.

package/lib/jwks.js

@@ -10,7 +10,7 @@ import { addressFromUncompressedPubkey, secp } from "./secp.js";
  * result-signing key). `kid` is the key's ETH address; `x`/`y` are the
  * uncompressed public-key coordinates. Empty set when no key is configured.
  */
-export function jwksFromPrivateKey(privateKeyHex) {
+export function jwksFromPrivateKey(privateKeyHex, metadata = {}) {
     if (!privateKeyHex) {
         return { keys: [] };
     }
@@ -23,6 +23,8 @@ export function jwksFromPrivateKey(privateKeyHex) {
                 crv: 'secp256k1',
                 alg: 'ES256K',
                 use: 'sig',
+                key_ops: ['verify'],
+                ...metadata,
                 kid: addressFromUncompressedPubkey(pub),
                 x: b64url(pub.subarray(1, 33)),
                 y: b64url(pub.subarray(33, 65)),
@@ -33,18 +35,65 @@ export function jwksFromPrivateKey(privateKeyHex) {
 /** Fetch the JWK set published at `<iss>/.well-known/jwks.json`. */
 export async function fetchJwks(iss, fetchImpl = fetch) {
     const base = iss.replace(/\/+$/, '');
-    const res = await fetchImpl(`${base}/.well-known/jwks.json`);
+    return fetchJwksUrl(`${base}/.well-known/jwks.json`, fetchImpl);
+}
+/** Fetch a JWK set from an explicitly trusted registry URL. */
+export async function fetchJwksUrl(url, fetchImpl = fetch) {
+    const jwks = await fetchReclaimJwks(url, fetchImpl);
+    return jwks.keys;
+}
+/** Fetch Builder's JWKS plus its namespaced attestor trust registry. */
+export async function fetchReclaimJwks(url, fetchImpl = fetch) {
+    const res = await fetchImpl(url);
     if (!res.ok) {
-        throw new Error(`JWKS fetch failed for ${base}: HTTP ${res.status}`);
+        throw new Error(`JWKS fetch failed for ${url}: HTTP ${res.status}`);
     }
     const body = (await res.json());
-    return body.keys ?? [];
+    return {
+        keys: body.keys ?? [],
+        'x-reclaim-attestors': validateAttestorAddresses(body['x-reclaim-attestors'] ?? []),
+    };
 }
 /** Find the key matching `kid` (case-insensitive — kids are ETH addresses). */
 export function selectKey(keys, kid) {
     const want = kid.toLowerCase();
     return keys.find((k) => (k.kid ?? '').toLowerCase() === want);
 }
+/** Select a result key and enforce its Verification Client ownership. */
+export function selectVerificationResultKey(keys, kid, verificationClientId) {
+    return keys.find((key) => ((key.kid ?? '').toLowerCase() === kid.toLowerCase()
+        && key['x-reclaim-purpose'] !== 'attestor-proof'
+        && belongsToVerificationClient(key, verificationClientId)));
+}
+/** Return ETH addresses from keys explicitly registered for attestor proofs. */
+export function trustedAttestorAddresses(keys) {
+    return keys
+        .filter((key) => key['x-reclaim-purpose'] === 'attestor-proof')
+        .map((key) => {
+        if (key.kty !== 'EC'
+            || key.crv !== 'secp256k1'
+            || key.use !== 'sig'
+            || key['x-reclaim-signature-scheme'] !== 'EIP-191'
+            || (key.key_ops && !key.key_ops.includes('verify'))) {
+            throw new Error('invalid attestor JWK metadata');
+        }
+        const address = addressFromUncompressedPubkey(hexPublicKeyBytes(jwkToUncompressedPublicKey(key))).toLowerCase();
+        if ((key.kid ?? '').toLowerCase() !== address) {
+            throw new Error('attestor JWK kid does not match its ETH public key');
+        }
+        return address;
+    });
+}
+/** Validate and normalize the JWKS address-only trust extension. */
+export function validateAttestorAddresses(addresses) {
+    return [...new Set(addresses.map((address) => {
+            const normalized = address.trim().toLowerCase();
+            if (!/^0x[0-9a-f]{40}$/.test(normalized)) {
+                throw new Error('invalid attestor address in JWKS trust registry');
+            }
+            return normalized;
+        }))];
+}
 /**
  * Reconstruct the uncompressed secp256k1 public key (`0x04` + X + Y) from an
  * EC JWK's base64url `x`/`y` coordinates, for signature verification.
@@ -61,3 +110,19 @@ export function jwkToUncompressedPublicKey(jwk) {
     out.set(y, 33);
     return '0x' + bytesToHex(out);
 }
+function belongsToVerificationClient(key, verificationClientId) {
+    const one = key['x-reclaim-verification-client-id'];
+    const many = key['x-reclaim-verification-client-ids'];
+    if (one) {
+        return one === verificationClientId;
+    }
+    if (many) {
+        return many.includes(verificationClientId);
+    }
+    // Untagged self-hosted JWKS remain compatible because their URL is itself
+    // selected from the registered Verification Client record.
+    return key['x-reclaim-purpose'] !== 'verification-result';
+}
+function hexPublicKeyBytes(value) {
+    return Uint8Array.from(Buffer.from(value.slice(2), 'hex'));
+}

package/lib/legacy-proof.d.ts

@@ -0,0 +1,57 @@
+import type { HashRequirement, LegacyProof, TrustedData } from './proof-types.ts';
+import { type AttestorTeeAttestationConfig } from './verify-attestor-tee.ts';
+import { type TeeAttestationConfig } from './verify-tee.ts';
+export type { LegacyProof } from './proof-types.ts';
+/** A proof hash requirement accepted by legacy `verifyProof`. */
+export type ProofHashRequirement = string | HashRequirement;
+export interface ResolvedSessionProofValidation {
+    hashes?: ProofHashRequirement[];
+    providerId?: string;
+    providerVersion?: string;
+    allowedTags?: string[];
+}
+/** Exact provider requirements returned by a caller-controlled resolver. */
+export interface ResolvedProviderProofValidation {
+    hashes: ProofHashRequirement[];
+}
+/** Options intentionally preserve legacy `verifyProof` vocabulary. */
+export interface LegacyVerifyProofOptions {
+    hashes?: ProofHashRequirement[];
+    providerId?: string;
+    providerVersion?: string;
+    allowedTags?: string[];
+    dangerouslyDisableContentValidation?: true;
+    /** Read `providerHash` from context, while still verifying signatures. */
+    hasNoPii?: true;
+    teeAttestation?: TeeAttestationConfig;
+    attestorTeeAttestation?: AttestorTeeAttestationConfig;
+    /** Explicit trusted attestor ETH addresses. */
+    attestorAddresses?: string[];
+    /** Trusted Builder JWKS registry containing attestor-purpose keys. */
+    attestorJwksUrl?: string;
+    fetchImpl?: typeof fetch;
+    /** Builder session id. Requires a resolver without hashes or a provider. */
+    sessionId?: string;
+    resolveSession?: (sessionId: string, proofs: LegacyProof[]) => Promise<ResolvedSessionProofValidation> | ResolvedSessionProofValidation;
+    /** Resolve an exact provider without coupling this verifier to HTTP. */
+    resolveProvider?: (providerId: string, providerVersion: string | undefined, allowedTags: string[] | undefined, proofs: LegacyProof[]) => Promise<ResolvedProviderProofValidation[]> | ResolvedProviderProofValidation[];
+    expectedSessionId?: string;
+    requireSessionBinding?: boolean;
+    expectedContext?: Record<string, unknown>;
+}
+export interface LegacyProofOutcome {
+    valid: boolean;
+    reason?: string;
+    proofHashes?: string[];
+    isTeeAttestationVerified?: boolean;
+    isAttestorTeeAttestationVerified?: boolean;
+    data?: TrustedData[];
+    publicData?: unknown[];
+}
+/** Return the provider hashes encoded in an exact legacy proof. */
+export declare function proofHashes(proof: LegacyProof): string[];
+/**
+ * Verify exact legacy proofs without depending on `@reclaimprotocol/js-sdk`.
+ * The signed claim is never renamed or reconstructed.
+ */
+export declare function verifyProof(proofOrProofs: LegacyProof | LegacyProof[], config: LegacyVerifyProofOptions): Promise<LegacyProofOutcome>;

package/lib/legacy-proof.js

@@ -0,0 +1,211 @@
+import { createSignDataForClaim } from '@reclaimprotocol/attestor-core';
+import { recoverEip191Address } from "./eip191.js";
+import { fetchReclaimJwks, trustedAttestorAddresses } from "./jwks.js";
+import { assertValidProofHashes, getHashFromProof } from "./proof-hash.js";
+import { runAttestorTeeVerification, } from "./verify-attestor-tee.js";
+import { runTeeVerification } from "./verify-tee.js";
+/** Return the provider hashes encoded in an exact legacy proof. */
+export function proofHashes(proof) {
+    return getHashFromProof(proof);
+}
+/**
+ * Verify exact legacy proofs without depending on `@reclaimprotocol/js-sdk`.
+ * The signed claim is never renamed or reconstructed.
+ */
+export async function verifyProof(proofOrProofs, config) {
+    const proofs = Array.isArray(proofOrProofs) ? proofOrProofs : [proofOrProofs];
+    if (!proofs.length) {
+        return { valid: false, reason: 'no-proofs' };
+    }
+    try {
+        const effective = await resolveValidation(config, proofs);
+        assertSessionAndContext(proofs, effective);
+        const attestors = await resolveTrustedAttestors(effective);
+        assertVerifiedSignatures(proofs, attestors);
+        await assertContent(proofs, effective);
+        let isTeeAttestationVerified;
+        if (effective.teeAttestation) {
+            await runTeeVerification(proofs, effective.teeAttestation);
+            isTeeAttestationVerified = true;
+        }
+        let isAttestorTeeAttestationVerified;
+        if (effective.attestorTeeAttestation) {
+            await runAttestorTeeVerification(proofs, effective.attestorTeeAttestation);
+            isAttestorTeeAttestationVerified = true;
+        }
+        return {
+            valid: true,
+            proofHashes: collectProofHashes(proofs, effective.hasNoPii),
+            isTeeAttestationVerified,
+            isAttestorTeeAttestationVerified,
+            data: proofs.map(trustedData),
+            publicData: proofs.map((proof) => proof.publicData ?? {}),
+        };
+    }
+    catch (error) {
+        return {
+            valid: false,
+            reason: failureReason(error),
+        };
+    }
+}
+async function resolveValidation(config, proofs) {
+    let effective = config;
+    if (config.sessionId && !hasContentValidation(config)) {
+        if (!config.resolveSession) {
+            throw new Error('session-resolver-required');
+        }
+        effective = {
+            ...config,
+            ...await config.resolveSession(config.sessionId, proofs),
+        };
+    }
+    return effective;
+}
+async function resolveTrustedAttestors(config) {
+    const addresses = config.attestorAddresses?.map(normalized) ?? [];
+    if (config.attestorJwksUrl) {
+        const registry = await fetchReclaimJwks(config.attestorJwksUrl, config.fetchImpl);
+        addresses.push(...(registry['x-reclaim-attestors'] ?? []), ...trustedAttestorAddresses(registry.keys));
+    }
+    const unique = [...new Set(addresses)];
+    if (!unique.length) {
+        throw new Error('attestor-trust-required');
+    }
+    return unique;
+}
+function assertVerifiedSignatures(proofs, trustedAttestors) {
+    for (const proof of proofs) {
+        if (!proof.signatures?.length || !proof.witnesses?.length) {
+            throw new Error('proof-signature-missing');
+        }
+        const signData = createSignDataForClaim(proof.claimData);
+        const signers = proof.signatures.map((signature) => (normalized(recoverEip191Address(signData, signature))));
+        const witnesses = proof.witnesses.map(({ id }) => normalized(id));
+        if (witnesses.some((witness) => !trustedAttestors.includes(witness))) {
+            throw new Error('attestor-not-allowed');
+        }
+        if (!signers.some((signer) => trustedAttestors.includes(signer))) {
+            throw new Error('attestor-not-allowed');
+        }
+        if (!signers.every((signer) => witnesses.includes(signer))) {
+            throw new Error('witness-signature-mismatch');
+        }
+    }
+}
+async function assertContent(proofs, config) {
+    if (config.dangerouslyDisableContentValidation) {
+        return;
+    }
+    if (config.hashes) {
+        assertValidProofHashes(proofs, config.hashes, config.hasNoPii);
+        return;
+    }
+    if (config.providerId) {
+        if (!config.resolveProvider) {
+            throw new Error('provider-resolver-required');
+        }
+        const candidates = await config.resolveProvider(config.providerId, config.providerVersion, config.allowedTags, proofs);
+        if (!candidates.length) {
+            throw new Error('provider-not-found');
+        }
+        let lastError;
+        for (const candidate of candidates) {
+            try {
+                assertValidProofHashes(proofs, candidate.hashes, config.hasNoPii);
+                return;
+            }
+            catch (error) {
+                lastError = error;
+            }
+        }
+        throw lastError;
+    }
+    throw new Error('proof-validation-required');
+}
+function assertSessionAndContext(proofs, config) {
+    const expectedSessionId = config.sessionId ?? config.expectedSessionId;
+    for (const proof of proofs) {
+        if (expectedSessionId) {
+            const ids = sessionIds(proof);
+            if (ids.some((id) => id !== expectedSessionId)) {
+                throw new Error('session-mismatch');
+            }
+            if ((config.sessionId || config.requireSessionBinding) && !ids.length) {
+                throw new Error('session-missing');
+            }
+        }
+        if (!contextMatches(proof, config.expectedContext)) {
+            throw new Error('context-mismatch');
+        }
+    }
+}
+function trustedData(proof) {
+    const context = contextFrom(proof);
+    const extractedParameters = isRecord(context.extractedParameters)
+        ? Object.fromEntries(Object.entries(context.extractedParameters).map(([key, value]) => [key, String(value)]))
+        : {};
+    delete context.extractedParameters;
+    return { context, extractedParameters };
+}
+function collectProofHashes(proofs, hasNoPii) {
+    try {
+        return proofs.flatMap((proof) => getHashFromProof(proof, hasNoPii));
+    }
+    catch {
+        return undefined;
+    }
+}
+function hasContentValidation(config) {
+    return Boolean(config.hashes
+        || config.providerId
+        || config.dangerouslyDisableContentValidation);
+}
+function failureReason(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const lower = message.toLowerCase();
+    if (lower.includes('multiple')
+        || lower.includes('duplicate')
+        || lower.includes('more than once')) {
+        return 'duplicate-proof-hash';
+    }
+    return message || 'proof-not-verified';
+}
+function normalized(value) {
+    return value.trim().toLowerCase();
+}
+function contextFrom(proof) {
+    const raw = proof.claimData.context;
+    if (!raw) {
+        return {};
+    }
+    try {
+        const context = JSON.parse(raw);
+        return isRecord(context) ? { ...context } : {};
+    }
+    catch {
+        return {};
+    }
+}
+function sessionIds(proof) {
+    const context = contextFrom(proof);
+    const ids = [context.reclaimSessionId];
+    try {
+        const parameters = JSON.parse(proof.claimData.parameters);
+        ids.push(parameters.proxySessionId, parameters.sessionId);
+    }
+    catch {
+        // A non-HTTP claim is valid when session binding wasn't requested.
+    }
+    return ids.filter((value) => (typeof value === 'string' && value.length > 0));
+}
+function contextMatches(proof, expected) {
+    if (!expected) {
+        return true;
+    }
+    const context = contextFrom(proof);
+    return Object.entries(expected).every(([key, value]) => (JSON.stringify(context[key]) === JSON.stringify(value)));
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}

package/lib/proof-hash.d.ts

@@ -0,0 +1,35 @@
+import type { HashRequirement, LegacyProof } from './proof-types.ts';
+export interface HttpProofParams {
+    url: string;
+    method: string;
+    body?: string;
+    responseMatches: Array<{
+        type?: string;
+        value?: string;
+        invert?: boolean;
+        isOptional?: boolean;
+    }>;
+    responseRedactions: Array<{
+        xPath?: string;
+        jsonPath?: string;
+        regex?: string;
+        hash?: string;
+    }>;
+}
+export interface ProofRequestSpec extends HttpProofParams {
+    urlType: string;
+    bodySniff: {
+        enabled: boolean;
+        template: string;
+    };
+    required?: boolean;
+    multiple?: boolean;
+    templateParams?: string[];
+    templateParamsMode?: 'separate' | 'merge';
+}
+/** Exact legacy canonical HTTP-provider hashes, including optional matches. */
+export declare function hashProofClaimParams(params: HttpProofParams): string[];
+export declare function getHashFromProof(proof: LegacyProof, hasNoPii?: boolean): string[];
+export declare function hashRequestSpec(request: ProofRequestSpec): HashRequirement;
+export declare function hashRequirementsFromSpecs(requestData: ProofRequestSpec[], allowedInjectedRequestData: ProofRequestSpec[], proofs: LegacyProof[]): HashRequirement[];
+export declare function assertValidProofHashes(proofs: LegacyProof[], requirements: Array<string | HashRequirement>, hasNoPii?: boolean): void;