@zkproofport-app/sdk 0.5.0-beta.2 → 0.5.0-beta.3

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { checkProofIssuer, parseProofForOnChain, verifyProofOnChain, getPinnedVerifier, extractScopeFromPublicInputs, extractNullifierFromPublicInputs, extractDomainFromPublicInputs } from '@zkproofport-app/core';
-export { COINBASE_ATTESTATION_PUBLIC_INPUT_LAYOUT, COINBASE_COUNTRY_PUBLIC_INPUT_LAYOUT, MDL_KR_PUBLIC_INPUT_LAYOUT, OIDC_DOMAIN_ATTESTATION_PUBLIC_INPUT_LAYOUT, PINNED_VERIFIERS, extractDomainFromPublicInputs, extractNullifierFromPublicInputs, extractScopeFromPublicInputs, getPinnedVerifier } from '@zkproofport-app/core';
+export { COINBASE_ATTESTATION_PUBLIC_INPUT_LAYOUT, COINBASE_COUNTRY_PUBLIC_INPUT_LAYOUT, MDL_KR_PUBLIC_INPUT_LAYOUT, OIDC_ALLOWED_AUDIENCES, OIDC_DOMAIN_ATTESTATION_PUBLIC_INPUT_LAYOUT, OIDC_NONCE_DOMAIN, OIDC_NOW_MAX_AGE_SECONDS, OIDC_NOW_MAX_FUTURE_SECONDS, OIDC_V1_PUBLIC_INPUT_COUNT, OIDC_V2_PUBLIC_INPUT_COUNT, PINNED_VERIFIERS, checkOidcPolicy, deriveOidcNonceBinding, extractDomainFromPublicInputs, extractNullifierFromPublicInputs, extractScopeFromPublicInputs, getPinnedVerifier, oidcAudienceHash } from '@zkproofport-app/core';
 import { isCircuitId, ALL_CIRCUIT_IDS, circuitActionBinding, CIRCUIT_VK_PATHS, CIRCUIT_NEEDS_WALLET_SIGNATURE } from '@zkproofport-app/core/circuits';
 export { ALL_CIRCUIT_IDS, CIRCUIT_ACTION_BINDING, CIRCUIT_IDS, CIRCUIT_SUPPORT_STATUS, CIRCUIT_VK_PATHS, EXPERIMENTAL_CIRCUIT_IDS, PLANNED_CIRCUIT_IDS, SUPPORTED_CIRCUIT_IDS, circuitActionBinding, getCircuitSupportStatus, isCircuitId, isSupportedCircuitId } from '@zkproofport-app/core/circuits';
 import { validateTypedAction } from '@zkproofport-app/core/typedAction';
@@ -124,8 +124,10 @@ const CIRCUIT_METADATA = {
     oidc_domain_attestation: {
         name: 'OIDC Domain',
         description: 'Prove email domain affiliation via OIDC JWT',
-        publicInputsCount: 148,
-        publicInputNames: ['pubkey_modulus_limbs', 'domain', 'scope', 'nullifier', 'provider'],
+        // v2: 148 v1 fields, then aud_hash (32), nonce_mode (1), nonce_binding
+        // (32), now (1). oidc-domain-attestation/src/main.nr.
+        publicInputsCount: 214,
+        publicInputNames: ['pubkey_modulus_limbs', 'domain', 'scope', 'nullifier', 'provider', 'aud_hash', 'nonce_mode', 'nonce_binding', 'now'],
     },
     // Planned circuit — the identifier is reserved and the circuit exists, but it
     // is not officially supported yet. See CIRCUIT_SUPPORT_STATUS in ./circuits.
@@ -4006,9 +4008,11 @@ async function fetchVerificationKey(circuit, timeoutMs) {
  * Needs no setup from the caller: the verifier ships with this SDK and is
  * loaded on first use.
  *
- * For `oidc_domain_attestation` it first checks the proof's RSA key against the
- * provider's published JWKS (core's `checkOidcProviderKey`); a key the provider
- * does not publish, or a JWKS that cannot be fetched, is `{ valid: false }`.
+ * For `oidc_domain_attestation` it first checks the token's audience, nonce and
+ * time (core's `checkOidcPolicy`, against `options.request` when given) and the
+ * proof's RSA key against the provider's published JWKS (core's
+ * `checkOidcProviderKey`); any refusal, or a JWKS that cannot be fetched, is
+ * `{ valid: false }`.
  *
  * @param circuit - Canonical circuit identifier
  * @param proof - Proof bytes as hex, WITHOUT public inputs (as the relay sends it)
@@ -4036,7 +4040,7 @@ async function verifyProofOffChain(circuit, proof, publicInputs, options = {}) {
     // their trust anchor as a public input the prover chooses. For OIDC that is
     // the RSA key -- see core's oidcProviderKeys. Checked here so a dApp that
     // verifies off-chain gets the same answer as one that verifies on-chain.
-    const issuer = await checkProofIssuer(circuit, publicInputs);
+    const issuer = await checkProofIssuer(circuit, publicInputs, { request: options.request });
     if (!issuer.ok) {
         return { valid: false, error: issuer.error };
     }
@@ -4178,6 +4182,13 @@ class ProofportSDK {
      */
     constructor(config = {}) {
         this.pendingRequests = new Map();
+        /**
+         * requestId -> scope of the relay requests this instance created, so that
+         * verifyResponse* can check an OIDC proof's request-bound nonce without the
+         * dApp passing the request back in. Oldest entries go first past
+         * {@link ProofportSDK.MAX_REMEMBERED_RELAY_REQUESTS}.
+         */
+        this.relayRequests = new Map();
         this.signer = null;
         this.socket = null;
         /**
@@ -4739,9 +4750,49 @@ class ProofportSDK {
      * }
      * ```
      */
-    async verifyOnChain(circuit, proof, publicInputs, providerOrSigner) {
+    async verifyOnChain(circuit, proof, publicInputs, providerOrSigner, options = {}) {
         const parsedProof = parseProofForOnChain(proof, publicInputs, publicInputs.length);
-        return verifyProofOnChain(circuit, parsedProof, providerOrSigner, this.verifierTarget(circuit));
+        return verifyProofOnChain(circuit, parsedProof, providerOrSigner, this.verifierTarget(circuit), undefined, {
+            request: options.request,
+        });
+    }
+    /**
+     * The request an `oidc_domain_attestation` response answers: the one the
+     * caller passed, else the relay request this instance created under the
+     * response's requestId. `{ error }` when there is none, or when the two
+     * disagree -- an OIDC proof made with a request-bound nonce is only
+     * meaningful against the request it was bound to, so a response this SDK
+     * cannot place is refused rather than checked without it.
+     */
+    oidcRequestFor(response, explicit) {
+        if (explicit !== undefined) {
+            if (explicit === null || typeof explicit !== 'object' || explicit.requestId !== response.requestId) {
+                return {
+                    error: `The request passed in (${JSON.stringify(explicit?.requestId)}) is not the one this response answers (${JSON.stringify(response.requestId)}).`,
+                };
+            }
+            return { request: explicit };
+        }
+        const remembered = this.relayRequests.get(response.requestId);
+        if (!remembered) {
+            return {
+                error: `No request ${JSON.stringify(response.requestId)} was created by this SDK instance, so the OIDC proof's ` +
+                    'nonce cannot be checked against it. Pass { request: { scope, requestId } } -- the scope and relay ' +
+                    'requestId of the request you created.',
+            };
+        }
+        return { request: remembered };
+    }
+    /** @internal Remember a relay request's scope for verifyResponse*. */
+    rememberRelayRequest(requestId, scope) {
+        if (typeof requestId !== 'string' || typeof scope !== 'string')
+            return;
+        this.relayRequests.delete(requestId);
+        this.relayRequests.set(requestId, { scope, requestId });
+        while (this.relayRequests.size > ProofportSDK.MAX_REMEMBERED_RELAY_REQUESTS) {
+            const oldest = this.relayRequests.keys().next().value;
+            this.relayRequests.delete(oldest);
+        }
     }
     /**
      * The verifier for a circuit: the one the dApp configured, otherwise the
@@ -4768,6 +4819,9 @@ class ProofportSDK {
      *
      * @param response - ProofResponse object from parseResponse()
      * @param providerOrSigner - ethers v6 Provider or Signer (defaults to base mainnet public RPC)
+     * @param options.request - For `oidc_domain_attestation`: the `{ scope, requestId }`
+     *   the response answers. Not needed for a relay request this SDK instance
+     *   created; an OIDC response this instance cannot place is refused without it.
      *
      * @returns Promise resolving to verification result with valid boolean and optional error message
      *
@@ -4794,10 +4848,17 @@ class ProofportSDK {
      * });
      * ```
      */
-    async verifyResponseOnChain(response, providerOrSigner) {
+    async verifyResponseOnChain(response, providerOrSigner, options = {}) {
         if (response.status !== 'completed' || !response.proof || !response.publicInputs) {
             return { valid: false, error: 'Invalid or incomplete response' };
         }
+        let request;
+        if (response.circuit === 'oidc_domain_attestation') {
+            const found = this.oidcRequestFor(response, options.request);
+            if ('error' in found)
+                return { valid: false, error: found.error };
+            request = found.request;
+        }
         const parsedProof = parseProofForOnChain(response.proof, response.publicInputs, response.publicInputs.length);
         // The response's verifierAddress and chainId are a claim to check, never
         // the contract to call: whoever wrote the response would otherwise pick
@@ -4806,7 +4867,7 @@ class ProofportSDK {
         return verifyProofOnChain(response.circuit, parsedProof, providerOrSigner, this.verifierTarget(response.circuit), {
             verifierAddress: response.verifierAddress,
             chainId: response.chainId,
-        });
+        }, { request });
     }
     /**
      * Verifies a proof response off-chain, against the circuit's verification key.
@@ -4836,7 +4897,14 @@ class ProofportSDK {
         if (response.status !== 'completed' || !response.proof || !response.publicInputs) {
             return { valid: false, error: 'Invalid or incomplete response' };
         }
-        return verifyProofOffChain(response.circuit, response.proof, response.publicInputs, options);
+        let request;
+        if (response.circuit === 'oidc_domain_attestation') {
+            const found = this.oidcRequestFor(response, options?.request);
+            if ('error' in found)
+                return { valid: false, error: found.error };
+            request = found.request;
+        }
+        return verifyProofOffChain(response.circuit, response.proof, response.publicInputs, { ...options, request });
     }
     // ============ Utility Methods ============
     /**
@@ -5275,7 +5343,9 @@ class ProofportSDK {
             const error = await response.json().catch(() => ({ error: `HTTP ${response.status}` }));
             throw new Error(error.error || `Relay request failed: HTTP ${response.status}`);
         }
-        return await response.json();
+        const created = await response.json();
+        this.rememberRelayRequest(created.requestId, scope);
+        return created;
     }
     /**
      * Polls the relay for proof result status.
@@ -5558,6 +5628,8 @@ class ProofportSDK {
         return extractDomainFromPublicInputs(publicInputs, circuit);
     }
 }
+/** Bound on {@link relayRequests}; a dApp that verifies later can pass the request explicitly. */
+ProofportSDK.MAX_REMEMBERED_RELAY_REQUESTS = 1000;
 /**
  * How each circuit's request is built and checked. Keyed by circuit id and
  * exhaustive over it, so a new circuit is a compile error here instead of