@reclaimprotocol/client 0.1.0-dev.1 → 0.1.0-dev.2

package/lib/result.js

@@ -0,0 +1,298 @@
+/**
+ * Consumer-side handling of a delivered callback. Two entry points:
+ *  - {@link verifyResult}: the offline primitive — decrypt + decode + optional
+ *    ES256K signature check (caller-supplied key) + `reclaimSessionId` nonce.
+ *  - {@link verifyResultFull}: the full async verification — discovers the
+ *    Verification Client's key via JWKS, verifies the top-level JWS, checks
+ *    `reclaimSessionId`/`aud`/`exp`, and verifies each result's nested attestor
+ *    proof + `content_hash` (see ./attestor-proof.ts and ./jwks.ts).
+ *
+ * See docs/verification-session.md → "Verification by Consumer".
+ */
+import { sha256 } from '@noble/hashes/sha2.js';
+import { keccak_256 } from '@noble/hashes/sha3.js';
+import { compactDecrypt, CompactEncrypt, importJWK } from 'jose';
+import { verifyNestedProof } from "./attestor-proof.js";
+import { canonicalJson } from "./canonical.js";
+import { b64url, base64urlToBytes, bytesToHex, hexToBytes } from "./encoding.js";
+import { fetchJwks, jwkToUncompressedPublicKey, selectKey } from "./jwks.js";
+import { addressFromUncompressedPubkey, secp } from "./secp.js";
+/**
+ * JWE-encrypt `plaintext` for the holder of `publicJwk` (an X25519 public JWK,
+ * `{kty:'OKP', crv:'X25519', x}`) as a compact JWE (`ECDH-ES + A256GCM`). Used
+ * by the first-party Verification Client to encrypt the signed JWS for each
+ * Consumer before submitting it to the Builder (which only relays the
+ * ciphertext). Consumers never call this — they only {@link decryptCallback}.
+ *
+ * `plaintext` is bytes (e.g. `new TextEncoder().encode(JSON.stringify(jws))`);
+ * returns the compact JWE string.
+ */
+export async function encryptForPublicJwk(publicJwk, plaintext) {
+    const key = await importJWK(publicJwk, 'ECDH-ES');
+    return new CompactEncrypt(plaintext)
+        .setProtectedHeader({ alg: 'ECDH-ES', enc: 'A256GCM' })
+        .encrypt(key);
+}
+/** Normalize any {@link CallbackBody} to the terminal-result `data` string —
+ *  either a compact JWE (`xxxx.yyyy.zzzz.aaaa.bbbb`) or the plaintext JWS JSON
+ *  (`{…}`). The envelope object/text wraps it in `.data`; raw bytes are decoded
+ *  to text first. */
+function payloadFrom(body) {
+    if (typeof body === 'string') {
+        const s = body.trim();
+        // A JSON envelope/JWS starts with '{'; anything else is the bare `data`
+        // (compact JWE). An envelope's `data` is extracted; a bare JWS is returned.
+        if (s.startsWith('{')) {
+            const parsed = JSON.parse(s);
+            if (typeof parsed.data === 'string') {
+                return parsed.data;
+            }
+            return s;
+        }
+        return s;
+    }
+    if (body instanceof ArrayBuffer) {
+        return payloadFrom(new TextDecoder().decode(new Uint8Array(body)));
+    }
+    if (body instanceof Uint8Array) {
+        return payloadFrom(new TextDecoder().decode(body));
+    }
+    return body.data;
+}
+/**
+ * Decrypt a delivered terminal callback to the signed JWS. `data` is either a
+ * compact JWE (decrypted with the X25519 `privateKey`) or — when the org has no
+ * encryption credential — the plaintext JWS JSON. A compact JWE has exactly
+ * five dot-separated base64url segments; a JSON JWS starts with `{`.
+ *
+ * `privateKey` may be absent (plaintext delivery); an encrypted delivery with
+ * no key throws a clear error.
+ */
+export async function decryptCallback(privateKey, body) {
+    const data = payloadFrom(body);
+    const trimmed = data.trim();
+    // Plaintext delivery: `data` is the JWS JSON directly.
+    if (trimmed.startsWith('{')) {
+        return JSON.parse(trimmed);
+    }
+    // Otherwise it's a compact JWE — five base64url segments.
+    if (!privateKey) {
+        throw new Error('received an encrypted (JWE) delivery but no decryption credential was '
+            + 'configured — pass the X25519 private key (JWK/PEM): '
+            + 'results.receive(body, { credential }) or decrypt(body, credential)');
+    }
+    const { plaintext } = await compactDecrypt(trimmed, privateKey);
+    return JSON.parse(new TextDecoder().decode(plaintext));
+}
+/**
+ * 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.
+ */
+export function signResultJws(privateKeyHex, payload, iss) {
+    const priv = hexToBytes(privateKeyHex);
+    const protectedHeader = b64url(JSON.stringify({
+        alg: 'ES256K',
+        kid: addressFromUncompressedPubkey(secp.getPublicKey(priv, false)),
+        typ: 'JWS',
+        iss,
+    }));
+    const payloadB64 = b64url(JSON.stringify(payload));
+    const signingInput = new TextEncoder().encode(`${protectedHeader}.${payloadB64}`);
+    // Standard ES256K: a single SHA-256 of the signing input. `prehash:false`
+    // stops @noble hashing the digest again, so any JOSE tool can verify it.
+    const sig = secp.sign(sha256(signingInput), priv, { prehash: false });
+    return {
+        payload: payloadB64,
+        signatures: [{ protected: protectedHeader, signature: b64url(sig) }],
+    };
+}
+/** Decode the JWS payload (base64url JSON). */
+export function decodeJwsPayload(jws) {
+    return JSON.parse(new TextDecoder().decode(base64urlToBytes(jws.payload)));
+}
+/**
+ * Verify a JWS signature (JOSE ES256K = ECDSA/secp256k1 over SHA-256 of the
+ * `<protected>.<payload>` signing input) with an uncompressed public key.
+ */
+export function verifyJwsSignature(jws, signerPublicKey) {
+    const pub = hexToBytes(signerPublicKey);
+    return jws.signatures.some((s) => {
+        try {
+            const signingInput = new TextEncoder().encode(`${s.protected}.${jws.payload}`);
+            const digest = sha256(signingInput);
+            const sig = base64urlToBytes(s.signature);
+            // digest is the single SHA-256 of the signing input — don't let
+            // @noble hash it again (standard ES256K).
+            return secp.verify(sig, digest, pub, { prehash: false });
+        }
+        catch {
+            return false;
+        }
+    });
+}
+/** Content hash binding extracted parameters — MUST mirror the Verification
+ *  Client's `contentHash` exactly (keccak256 of the RFC 8785 canonical JSON,
+ *  via the shared `canonicalJson`). */
+function contentHash(params) {
+    const canonical = canonicalJson(params);
+    return '0x' + bytesToHex(keccak_256(new TextEncoder().encode(canonical)));
+}
+/**
+ * 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 })
+ *     // result is verified — use result.payload
+ *   } catch (err) {
+ *     if (err instanceof ResultVerificationError) {
+ *       // e.g. 'expired', { payload, … }
+ *       console.error(err.reason, err.outcome)
+ *     }
+ *   }
+ */
+export class ResultVerificationError extends Error {
+    /** Machine-readable failure reason — `'bad-signature'`, `'expired'`,
+     *  `'reclaimSessionId-mismatch'`, `'aud-mismatch'`, `'invalid-proof'`, … */
+    reason;
+    /** The full (invalid) outcome: `payload`, `reclaimSessionId`, and per-proof
+     *  detail (`proofs`) when verification got that far. */
+    outcome;
+    constructor(outcome) {
+        super(`result verification failed: ${outcome.reason ?? 'invalid'}`);
+        this.name = 'ResultVerificationError';
+        this.reason = outcome.reason ?? 'invalid';
+        this.outcome = outcome;
+    }
+}
+/**
+ * Full consumer verification: discovers the Verification Client's signing key
+ * via JWKS (header `iss`/`kid`), verifies the top-level JWS, checks
+ * `reclaimSessionId`/`aud`/`exp`, then verifies each result's nested attestor
+ * proof and its `content_hash`. Network access (JWKS) makes this async; use
+ * {@link verifyResult} for the offline primitive.
+ */
+export async function verifyResultFull(jws, opts = {}) {
+    const payload = decodeJwsPayload(jws);
+    const reclaimSessionId = payload.reclaimSessionId;
+    /** 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: explicit override, else JWKS via header iss.
+    let signerPublicKey = opts.signerPublicKey;
+    let header = {};
+    const sig0 = jws.signatures[0];
+    if (sig0) {
+        try {
+            header = JSON.parse(new TextDecoder().decode(base64urlToBytes(sig0.protected)));
+        }
+        catch {
+            return fail('bad-header');
+        }
+    }
+    if (!signerPublicKey) {
+        const iss = String(header.iss ?? '');
+        if (!iss) {
+            return fail('no-issuer');
+        }
+        const keys = await fetchJwks(iss, opts.fetchImpl);
+        const jwk = selectKey(keys, String(header.kid ?? ''));
+        if (!jwk) {
+            return fail('signer-key-not-found');
+        }
+        signerPublicKey = jwkToUncompressedPublicKey(jwk);
+    }
+    if (!verifyJwsSignature(jws, signerPublicKey)) {
+        return fail('bad-signature');
+    }
+    // 2. Freshness / audience / expiry.
+    if (opts.expectedReclaimSessionId &&
+        reclaimSessionId !== opts.expectedReclaimSessionId) {
+        return fail('reclaimSessionId-mismatch');
+    }
+    if (opts.expectedAud && payload.aud !== opts.expectedAud) {
+        return fail('aud-mismatch');
+    }
+    const now = opts.now ?? Math.floor(Date.now() / 1000);
+    if (typeof payload.exp === 'number' && payload.exp < now) {
+        return fail('expired');
+    }
+    // 3. Per-result nested attestor proof + content_hash binding.
+    const results = Array.isArray(payload.results)
+        ? payload.results
+        : [];
+    const proofs = [];
+    for (const r of results) {
+        const requestId = typeof r.request_id === 'string' ? r.request_id : undefined;
+        if (typeof r.proof !== 'string') {
+            proofs.push({ requestId, proofValid: false, reason: 'proof-missing' });
+            continue;
+        }
+        const np = verifyNestedProof(r.proof, {
+            attestorAddresses: opts.attestorAddresses,
+        });
+        if (!np.valid) {
+            proofs.push({
+                requestId,
+                proofValid: false,
+                reason: np.reason,
+                attestorAddress: np.attestorAddress,
+            });
+            continue;
+        }
+        if (typeof r.content_hash === 'string' &&
+            r.extracted_parameters &&
+            typeof r.extracted_parameters === 'object') {
+            const params = r.extracted_parameters;
+            if (contentHash(params).toLowerCase() !== r.content_hash.toLowerCase()) {
+                proofs.push({
+                    requestId,
+                    proofValid: false,
+                    reason: 'content-hash-mismatch',
+                    attestorAddress: np.attestorAddress,
+                });
+                continue;
+            }
+        }
+        proofs.push({
+            requestId,
+            proofValid: true,
+            attestorAddress: np.attestorAddress,
+        });
+    }
+    if (!proofs.every((p) => p.proofValid)) {
+        return fail('invalid-proof', { proofs });
+    }
+    return { valid: true, payload, reclaimSessionId, proofs };
+}
+/** Decrypt-and-verify in one step. */
+export function verifyResult(jws, opts = {}) {
+    const payload = decodeJwsPayload(jws);
+    const reclaimSessionId = payload.reclaimSessionId;
+    if (opts.signerPublicKey && !verifyJwsSignature(jws, opts.signerPublicKey)) {
+        throw new ResultVerificationError({
+            valid: false, reason: 'bad-signature', payload, reclaimSessionId,
+        });
+    }
+    if (opts.expectedReclaimSessionId &&
+        reclaimSessionId !== opts.expectedReclaimSessionId) {
+        throw new ResultVerificationError({
+            valid: false,
+            reason: 'reclaimSessionId-mismatch',
+            payload,
+            reclaimSessionId,
+        });
+    }
+    return { valid: true, payload, reclaimSessionId };
+}

package/lib/routes.gen.d.ts

@@ -3,6 +3,10 @@ export declare const ROUTES: {
         readonly method: "post";
         readonly path: "/orgs/{orgId}/members";
     };
+    readonly AdminCallbackDlq: {
+        readonly method: "get";
+        readonly path: "/admin/callback-dlq";
+    };
     readonly AdminHome: {
         readonly method: "get";
         readonly path: "/admin";
@@ -19,6 +23,10 @@ export declare const ROUTES: {
         readonly method: "get";
         readonly path: "/admin/reviews";
     };
+    readonly AdminSessions: {
+        readonly method: "get";
+        readonly path: "/admin/sessions";
+    };
     readonly AdminThemes: {
         readonly method: "get";
         readonly path: "/admin/themes";
@@ -47,10 +55,18 @@ export declare const ROUTES: {
         readonly method: "post";
         readonly path: "/credentials/attach/sessions";
     };
+    readonly CreateCallbackSubscription: {
+        readonly method: "post";
+        readonly path: "/verifications/callback-subscriptions";
+    };
     readonly CreateOrg: {
         readonly method: "post";
         readonly path: "/orgs";
     };
+    readonly CreateOrgCallbackSubscription: {
+        readonly method: "post";
+        readonly path: "/orgs/{orgId}/callback-subscriptions";
+    };
     readonly CreateProvider: {
         readonly method: "post";
         readonly path: "/providers";
@@ -63,18 +79,18 @@ export declare const ROUTES: {
         readonly method: "post";
         readonly path: "/orgs/{orgId}/themes";
     };
-    readonly CredentialAuthChallenge: {
+    readonly CreateVerificationSession: {
         readonly method: "post";
-        readonly path: "/credentials/auth/challenge";
-    };
-    readonly CredentialAuthVerify: {
-        readonly method: "post";
-        readonly path: "/credentials/auth/verify";
+        readonly path: "/verifications/sessions";
     };
     readonly DecideProviderVersionReview: {
         readonly method: "post";
         readonly path: "/providers/{providerId}/versions/{version}/review-decision";
     };
+    readonly DeleteCallbackSubscription: {
+        readonly method: "delete";
+        readonly path: "/verifications/callback-subscriptions/{subscriptionId}";
+    };
     readonly DeleteOrg: {
         readonly method: "delete";
         readonly path: "/orgs/{orgId}";
@@ -83,6 +99,14 @@ export declare const ROUTES: {
         readonly method: "delete";
         readonly path: "/orgs/{orgId}/billing";
     };
+    readonly DeleteOrgCallbackSubscription: {
+        readonly method: "delete";
+        readonly path: "/orgs/{orgId}/callback-subscriptions/{subscriptionId}";
+    };
+    readonly DeleteOrgCredential: {
+        readonly method: "delete";
+        readonly path: "/orgs/{orgId}/credential";
+    };
     readonly DeleteOrgIcon: {
         readonly method: "delete";
         readonly path: "/orgs/{orgId}/icon";
@@ -111,14 +135,6 @@ export declare const ROUTES: {
         readonly method: "get";
         readonly path: "/credentials/attach/sessions/{code}";
     };
-    readonly GetCredential: {
-        readonly method: "get";
-        readonly path: "/credentials/{credentialId}";
-    };
-    readonly GetCredentialByAddress: {
-        readonly method: "get";
-        readonly path: "/credentials/by-address/{address}";
-    };
     readonly GetImage: {
         readonly method: "get";
         readonly path: "/images/{imageId}";
@@ -135,6 +151,18 @@ export declare const ROUTES: {
         readonly method: "get";
         readonly path: "/orgs/{orgId}/billing";
     };
+    readonly GetOrgCredential: {
+        readonly method: "get";
+        readonly path: "/orgs/{orgId}/credential";
+    };
+    readonly GetOrgSession: {
+        readonly method: "get";
+        readonly path: "/orgs/{orgId}/sessions/{sessionId}";
+    };
+    readonly GetOrgToken: {
+        readonly method: "get";
+        readonly path: "/orgs/{orgId}/token";
+    };
     readonly GetProvider: {
         readonly method: "get";
         readonly path: "/providers/{providerId}";
@@ -155,30 +183,70 @@ export declare const ROUTES: {
         readonly method: "get";
         readonly path: "/users/{userId}";
     };
+    readonly GetVerificationRecipe: {
+        readonly method: "get";
+        readonly path: "/verifications/sessions/{sessionId}/recipe";
+    };
+    readonly GetVerificationResult: {
+        readonly method: "get";
+        readonly path: "/verifications/sessions/{sessionId}/result";
+    };
+    readonly GetVerificationSession: {
+        readonly method: "get";
+        readonly path: "/verifications/sessions/{sessionId}";
+    };
     readonly Index: {
         readonly method: "get";
         readonly path: "/";
     };
-    readonly LinkCredential: {
+    readonly IssueOrgToken: {
         readonly method: "post";
-        readonly path: "/credentials";
+        readonly path: "/orgs/{orgId}/token";
     };
-    readonly ListOrgCredentials: {
+    readonly JwksJson: {
         readonly method: "get";
-        readonly path: "/orgs/{orgId}/credentials";
+        readonly path: "/.well-known/jwks.json";
+    };
+    readonly ListCallbackDlq: {
+        readonly method: "get";
+        readonly path: "/verifications/callback-dlq";
+    };
+    readonly ListCallbackSubscriptions: {
+        readonly method: "get";
+        readonly path: "/verifications/callback-subscriptions";
+    };
+    readonly ListOrgCallbackSubscriptions: {
+        readonly method: "get";
+        readonly path: "/orgs/{orgId}/callback-subscriptions";
     };
     readonly ListOrgs: {
         readonly method: "get";
         readonly path: "/orgs";
     };
+    readonly ListOrgVerificationSessions: {
+        readonly method: "get";
+        readonly path: "/orgs/{orgId}/sessions";
+    };
     readonly ListProviderVersions: {
         readonly method: "get";
         readonly path: "/providers/{providerId}/versions";
     };
+    readonly ListSessionCallbackKeys: {
+        readonly method: "get";
+        readonly path: "/verifications/sessions/{sessionId}/callback-keys";
+    };
     readonly ListThemes: {
         readonly method: "get";
         readonly path: "/orgs/{orgId}/themes";
     };
+    readonly ListVerificationDeliveries: {
+        readonly method: "get";
+        readonly path: "/verifications/sessions/{sessionId}/deliveries";
+    };
+    readonly ListVerificationEvents: {
+        readonly method: "get";
+        readonly path: "/verifications/sessions/{sessionId}/events";
+    };
     readonly Login: {
         readonly method: "post";
         readonly path: "/auth/login";
@@ -215,18 +283,34 @@ export declare const ROUTES: {
         readonly method: "delete";
         readonly path: "/orgs/{orgId}/members/{memberId}";
     };
+    readonly ReportClaimant: {
+        readonly method: "post";
+        readonly path: "/v/{sessionId}/claimant";
+    };
+    readonly ReportVerificationEvent: {
+        readonly method: "post";
+        readonly path: "/verifications/sessions/{sessionId}/events";
+    };
     readonly RequestPublicListing: {
         readonly method: "post";
         readonly path: "/providers/{providerId}/request-public";
     };
-    readonly RevokeCredential: {
-        readonly method: "delete";
-        readonly path: "/credentials/{credentialId}";
+    readonly RetryCallbackDlq: {
+        readonly method: "post";
+        readonly path: "/verifications/callback-dlq/{dlqId}/retry";
+    };
+    readonly RetryVerificationCallback: {
+        readonly method: "post";
+        readonly path: "/verifications/sessions/{sessionId}/retry-callback";
     };
     readonly Robots: {
         readonly method: "get";
         readonly path: "/robots.txt";
     };
+    readonly SetOrgCredential: {
+        readonly method: "put";
+        readonly path: "/orgs/{orgId}/credential";
+    };
     readonly SetupProviderCreate: {
         readonly method: "post";
         readonly path: "/providers/setup";
@@ -239,6 +323,10 @@ export declare const ROUTES: {
         readonly method: "post";
         readonly path: "/providers/{providerId}/versions/{version}/review";
     };
+    readonly SubmitVerificationResult: {
+        readonly method: "post";
+        readonly path: "/verifications/sessions/{sessionId}/result";
+    };
     readonly TransferProvider: {
         readonly method: "post";
         readonly path: "/providers/{providerId}/transfer";
@@ -275,5 +363,17 @@ export declare const ROUTES: {
         readonly method: "patch";
         readonly path: "/orgs/{orgId}/themes/{themeId}";
     };
+    readonly VerificationPage: {
+        readonly method: "get";
+        readonly path: "/v/{sessionId}";
+    };
+    readonly VerificationSessionSse: {
+        readonly method: "get";
+        readonly path: "/v/{sessionId}/sse";
+    };
+    readonly VerificationStatus: {
+        readonly method: "get";
+        readonly path: "/v/{sessionId}/status";
+    };
 };
 export type RouteId = keyof typeof ROUTES;

package/lib/routes.gen.js

@@ -4,10 +4,12 @@
 // to regenerate. Do not edit by hand.
 export const ROUTES = {
     "AddOrgMember": { "method": "post", "path": "/orgs/{orgId}/members" },
+    "AdminCallbackDlq": { "method": "get", "path": "/admin/callback-dlq" },
     "AdminHome": { "method": "get", "path": "/admin" },
     "AdminOrgs": { "method": "get", "path": "/admin/orgs" },
     "AdminProviders": { "method": "get", "path": "/admin/providers" },
     "AdminReviews": { "method": "get", "path": "/admin/reviews" },
+    "AdminSessions": { "method": "get", "path": "/admin/sessions" },
     "AdminThemes": { "method": "get", "path": "/admin/themes" },
     "AdminUsers": { "method": "get", "path": "/admin/users" },
     "AttachPage": { "method": "get", "path": "/attach/{code}" },
@@ -15,15 +17,19 @@ export const ROUTES = {
     "ComponentsDemo": { "method": "get", "path": "/components_demo" },
     "ConfirmAttachSession": { "method": "post", "path": "/credentials/attach/sessions/{code}/confirm" },
     "CreateAttachSession": { "method": "post", "path": "/credentials/attach/sessions" },
+    "CreateCallbackSubscription": { "method": "post", "path": "/verifications/callback-subscriptions" },
     "CreateOrg": { "method": "post", "path": "/orgs" },
+    "CreateOrgCallbackSubscription": { "method": "post", "path": "/orgs/{orgId}/callback-subscriptions" },
     "CreateProvider": { "method": "post", "path": "/providers" },
     "CreateProviderVersion": { "method": "post", "path": "/providers/{providerId}/versions" },
     "CreateTheme": { "method": "post", "path": "/orgs/{orgId}/themes" },
-    "CredentialAuthChallenge": { "method": "post", "path": "/credentials/auth/challenge" },
-    "CredentialAuthVerify": { "method": "post", "path": "/credentials/auth/verify" },
+    "CreateVerificationSession": { "method": "post", "path": "/verifications/sessions" },
     "DecideProviderVersionReview": { "method": "post", "path": "/providers/{providerId}/versions/{version}/review-decision" },
+    "DeleteCallbackSubscription": { "method": "delete", "path": "/verifications/callback-subscriptions/{subscriptionId}" },
     "DeleteOrg": { "method": "delete", "path": "/orgs/{orgId}" },
     "DeleteOrgBilling": { "method": "delete", "path": "/orgs/{orgId}/billing" },
+    "DeleteOrgCallbackSubscription": { "method": "delete", "path": "/orgs/{orgId}/callback-subscriptions/{subscriptionId}" },
+    "DeleteOrgCredential": { "method": "delete", "path": "/orgs/{orgId}/credential" },
     "DeleteOrgIcon": { "method": "delete", "path": "/orgs/{orgId}/icon" },
     "DeleteProvider": { "method": "delete", "path": "/providers/{providerId}" },
     "DeleteProviderVersion": { "method": "delete", "path": "/providers/{providerId}/versions/{version}" },
@@ -31,23 +37,34 @@ export const ROUTES = {
     "Docs": { "method": "get", "path": "/docs" },
     "ExplorePreviewImage": { "method": "get", "path": "/og/explore.png" },
     "GetAttachSession": { "method": "get", "path": "/credentials/attach/sessions/{code}" },
-    "GetCredential": { "method": "get", "path": "/credentials/{credentialId}" },
-    "GetCredentialByAddress": { "method": "get", "path": "/credentials/by-address/{address}" },
     "GetImage": { "method": "get", "path": "/images/{imageId}" },
     "GetMe": { "method": "get", "path": "/me" },
     "GetOrg": { "method": "get", "path": "/orgs/{orgId}" },
     "GetOrgBilling": { "method": "get", "path": "/orgs/{orgId}/billing" },
+    "GetOrgCredential": { "method": "get", "path": "/orgs/{orgId}/credential" },
+    "GetOrgSession": { "method": "get", "path": "/orgs/{orgId}/sessions/{sessionId}" },
+    "GetOrgToken": { "method": "get", "path": "/orgs/{orgId}/token" },
     "GetProvider": { "method": "get", "path": "/providers/{providerId}" },
     "GetProviderBySlug": { "method": "get", "path": "/providers/{providerId}/{slug}" },
     "GetProviderVersion": { "method": "get", "path": "/providers/{providerId}/versions/{version}" },
     "GetTheme": { "method": "get", "path": "/orgs/{orgId}/themes/{themeId}" },
     "GetUser": { "method": "get", "path": "/users/{userId}" },
+    "GetVerificationRecipe": { "method": "get", "path": "/verifications/sessions/{sessionId}/recipe" },
+    "GetVerificationResult": { "method": "get", "path": "/verifications/sessions/{sessionId}/result" },
+    "GetVerificationSession": { "method": "get", "path": "/verifications/sessions/{sessionId}" },
     "Index": { "method": "get", "path": "/" },
-    "LinkCredential": { "method": "post", "path": "/credentials" },
-    "ListOrgCredentials": { "method": "get", "path": "/orgs/{orgId}/credentials" },
+    "IssueOrgToken": { "method": "post", "path": "/orgs/{orgId}/token" },
+    "JwksJson": { "method": "get", "path": "/.well-known/jwks.json" },
+    "ListCallbackDlq": { "method": "get", "path": "/verifications/callback-dlq" },
+    "ListCallbackSubscriptions": { "method": "get", "path": "/verifications/callback-subscriptions" },
+    "ListOrgCallbackSubscriptions": { "method": "get", "path": "/orgs/{orgId}/callback-subscriptions" },
     "ListOrgs": { "method": "get", "path": "/orgs" },
+    "ListOrgVerificationSessions": { "method": "get", "path": "/orgs/{orgId}/sessions" },
     "ListProviderVersions": { "method": "get", "path": "/providers/{providerId}/versions" },
+    "ListSessionCallbackKeys": { "method": "get", "path": "/verifications/sessions/{sessionId}/callback-keys" },
     "ListThemes": { "method": "get", "path": "/orgs/{orgId}/themes" },
+    "ListVerificationDeliveries": { "method": "get", "path": "/verifications/sessions/{sessionId}/deliveries" },
+    "ListVerificationEvents": { "method": "get", "path": "/verifications/sessions/{sessionId}/events" },
     "Login": { "method": "post", "path": "/auth/login" },
     "LoginPage": { "method": "get", "path": "/login" },
     "Logout": { "method": "post", "path": "/logout" },
@@ -57,12 +74,17 @@ export const ROUTES = {
     "Providers": { "method": "get", "path": "/providers" },
     "PublishProviderVersion": { "method": "post", "path": "/providers/{providerId}/versions/{version}/publish" },
     "RemoveOrgMember": { "method": "delete", "path": "/orgs/{orgId}/members/{memberId}" },
+    "ReportClaimant": { "method": "post", "path": "/v/{sessionId}/claimant" },
+    "ReportVerificationEvent": { "method": "post", "path": "/verifications/sessions/{sessionId}/events" },
     "RequestPublicListing": { "method": "post", "path": "/providers/{providerId}/request-public" },
-    "RevokeCredential": { "method": "delete", "path": "/credentials/{credentialId}" },
+    "RetryCallbackDlq": { "method": "post", "path": "/verifications/callback-dlq/{dlqId}/retry" },
+    "RetryVerificationCallback": { "method": "post", "path": "/verifications/sessions/{sessionId}/retry-callback" },
     "Robots": { "method": "get", "path": "/robots.txt" },
+    "SetOrgCredential": { "method": "put", "path": "/orgs/{orgId}/credential" },
     "SetupProviderCreate": { "method": "post", "path": "/providers/setup" },
     "Sitemap": { "method": "get", "path": "/sitemap.xml" },
     "SubmitProviderVersionForReview": { "method": "post", "path": "/providers/{providerId}/versions/{version}/review" },
+    "SubmitVerificationResult": { "method": "post", "path": "/verifications/sessions/{sessionId}/result" },
     "TransferProvider": { "method": "post", "path": "/providers/{providerId}/transfer" },
     "UpdateMe": { "method": "patch", "path": "/me" },
     "UpdateOrg": { "method": "patch", "path": "/orgs/{orgId}" },
@@ -72,4 +94,7 @@ export const ROUTES = {
     "UpdateProvider": { "method": "patch", "path": "/providers/{providerId}" },
     "UpdateProviderVersion": { "method": "patch", "path": "/providers/{providerId}/versions/{version}" },
     "UpdateTheme": { "method": "patch", "path": "/orgs/{orgId}/themes/{themeId}" },
+    "VerificationPage": { "method": "get", "path": "/v/{sessionId}" },
+    "VerificationSessionSse": { "method": "get", "path": "/v/{sessionId}/sse" },
+    "VerificationStatus": { "method": "get", "path": "/v/{sessionId}/status" },
 };

package/lib/secp.d.ts

@@ -0,0 +1,6 @@
+import { keccak_256 } from '@noble/hashes/sha3.js';
+import * as secp from '@noble/secp256k1';
+export { keccak_256, secp };
+/** Lowercase 0x ETH address from an uncompressed (65-byte) public key:
+ *  keccak256 of the 64-byte X‖Y (drop the 0x04 prefix), last 20 bytes. */
+export declare function addressFromUncompressedPubkey(pub: Uint8Array): string;