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

package/dist/index.js

@@ -32,7 +32,7 @@ const RELAY_URLS = {
  * Mirrors the mobile app's `CIRCUIT_NETWORKS` (proofport-app
  * src/config/contracts.ts), because a proof is checked where the app said its
  * verifier is: Base for the Coinbase and OIDC circuits, GIWA Sepolia for GIWA
- * and Dojang (testnet-only), Base Sepolia for Korea Mobile ID (testnet-only).
+ * and Dojang (testnet-only).
  * The ADDRESS on that chain always comes from core's pinned table, never from
  * a proof response.
  */
@@ -43,9 +43,6 @@ const VERIFICATION_CHAINS = {
         oidc_domain_attestation: 8453,
         giwa_attestation: 91342,
         dojang_playground: 91342,
-        mdl_kr_ownership: 84532,
-        mdl_kr_age: 84532,
-        mdl_kr_region: 84532,
     },
     staging: {
         coinbase_attestation: 84532,
@@ -53,9 +50,6 @@ const VERIFICATION_CHAINS = {
         oidc_domain_attestation: 84532,
         giwa_attestation: 91342,
         dojang_playground: 91342,
-        mdl_kr_ownership: 84532,
-        mdl_kr_age: 84532,
-        mdl_kr_region: 84532,
     },
     local: {
         coinbase_attestation: 84532,
@@ -63,9 +57,6 @@ const VERIFICATION_CHAINS = {
         oidc_domain_attestation: 84532,
         giwa_attestation: 91342,
         dojang_playground: 91342,
-        mdl_kr_ownership: 84532,
-        mdl_kr_age: 84532,
-        mdl_kr_region: 84532,
     },
 };
 /**
@@ -126,8 +117,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.
@@ -160,27 +153,6 @@ const CIRCUIT_METADATA = {
         publicInputsCount: 160,
         publicInputNames: ['signal_hash', 'domain_separator', 'action_hash', 'scope', 'nullifier'],
     },
-    // Korea Mobile ID (mDL) circuits. Planned — not officially supported yet.
-    // Counts are byte-flattened field totals from the compiled circuit ABIs:
-    // [u8; 32] arrays contribute 32 inputs each.
-    mdl_kr_ownership: {
-        name: 'Korea Mobile ID — Ownership',
-        description: "Prove valid Korean mobile driver's license ownership with selective disclosure",
-        publicInputsCount: 97,
-        publicInputNames: ['scope', 'nullifier_value', 'disclose_flags', 'owner_commit'],
-    },
-    mdl_kr_age: {
-        name: 'Korea Mobile ID — Age',
-        description: "Prove minimum age from Korean mobile driver's license without revealing birth date",
-        publicInputsCount: 66,
-        publicInputNames: ['scope', 'nullifier_value', 'age_threshold', 'current_year'],
-    },
-    mdl_kr_region: {
-        name: 'Korea Mobile ID — Region',
-        description: "Prove si/do residency from Korean mobile driver's license without revealing address",
-        publicInputsCount: 96,
-        publicInputNames: ['scope', 'nullifier_value', 'region_code'],
-    },
 };
 /**
  * Default proof request expiration time in milliseconds.
@@ -424,6 +396,12 @@ function parseProofResponseUrl(url) {
             if (timestamp) {
                 response.timestamp = parseInt(timestamp, 10);
             }
+            // Kept as sent, even when unknown: verification refuses it by name,
+            // which says more than a callback that fails to parse.
+            const signerVariant = urlObj.searchParams.get('signerVariant');
+            if (signerVariant !== null) {
+                response.signerVariant = signerVariant;
+            }
         }
         else if (status === 'error') {
             response.error = urlObj.searchParams.get('error') || undefined;
@@ -455,94 +433,6 @@ function parseProofResponseUrl(url) {
 function isProofportDeepLink(url, scheme = DEFAULT_SCHEME) {
     return url.toLowerCase().startsWith(`${scheme.toLowerCase()}://`);
 }
-/**
- * @internal
- * Validates a proof request for completeness and correctness.
- *
- * Performs comprehensive validation including:
- * - Required fields (requestId, circuit, callbackUrl)
- * - Circuit type validity (must be a supported circuit)
- * - Circuit-specific input validation (e.g., userAddress format, countryList structure)
- * - Expiration check (if expiresAt is provided)
- *
- * Note: userAddress is optional for both circuits - the mobile app will prompt
- * for wallet connection if not provided.
- *
- * @param request - Proof request to validate
- * @returns Validation result with `valid` flag and optional `error` message
- */
-/**
- * Validates a free-text mDL input (scope / targetRegion).
- * Rejects empty or whitespace-only values, control characters (which break
- * deep-link query encoding and downstream logging), and values over 256 chars
- * (server-side length cap mirror). UTF-8 text such as Korean region names is
- * allowed.
- *
- * @returns Error message string, or null when valid.
- */
-function validateMdlTextInput(value, fieldName) {
-    if (typeof value !== 'string' || value.trim() === '') {
-        return `${fieldName} is required and must be a non-empty string`;
-    }
-    if (value.length > 256) {
-        return `${fieldName} must be 256 characters or fewer`;
-    }
-    // eslint-disable-next-line no-control-regex
-    if (/[\u0000-\u001F\u007F]/.test(value)) {
-        return `${fieldName} must not contain control characters`;
-    }
-    return null;
-}
-/**
- * Validates dapp-supplied inputs for the Korea Mobile ID (mDL) circuits.
- * Shared by deep-link request validation and relay request creation so the
- * same guards apply on every request path.
- *
- * Rules:
- * - `scope` — required non-empty string, ≤256 chars, no control characters
- * - `mdl_kr_ownership.discloseFlags` — optional integer 0–15 (0x0F bitmask)
- * - `mdl_kr_age.ageThreshold` — required integer 1–150
- * - `mdl_kr_region.targetRegion` — required non-empty string (Korean si/do),
- *   ≤256 chars, no control characters
- *
- * @param circuit - One of the three mDL circuit identifiers
- * @param inputs - Dapp-supplied circuit inputs
- * @returns Error message string, or null when the inputs are valid
- */
-function validateMdlInputs(circuit, inputs) {
-    const scopeError = validateMdlTextInput(inputs.scope, 'scope');
-    if (scopeError) {
-        return scopeError;
-    }
-    if (circuit === 'mdl_kr_ownership') {
-        const { discloseFlags } = inputs;
-        if (discloseFlags !== undefined) {
-            if (typeof discloseFlags !== 'number' ||
-                !Number.isInteger(discloseFlags) ||
-                discloseFlags < 0 ||
-                discloseFlags > 0x0f) {
-                return 'discloseFlags must be an integer between 0 and 15';
-            }
-        }
-    }
-    else if (circuit === 'mdl_kr_age') {
-        const { ageThreshold } = inputs;
-        if (typeof ageThreshold !== 'number' ||
-            !Number.isInteger(ageThreshold) ||
-            ageThreshold < 1 ||
-            ageThreshold > 150) {
-            return 'ageThreshold is required and must be an integer between 1 and 150';
-        }
-    }
-    else {
-        const { targetRegion } = inputs;
-        const regionError = validateMdlTextInput(targetRegion, 'targetRegion');
-        if (regionError) {
-            return regionError;
-        }
-    }
-    return null;
-}
 /**
  * Longest accepted `returnScheme` value.
  * Kept in sync with proofport-relay `src/returnScheme.ts`.
@@ -702,6 +592,22 @@ function detectReturnScheme(userAgent) {
     }
     return undefined;
 }
+/**
+ * @internal
+ * Validates a proof request for completeness and correctness.
+ *
+ * Performs comprehensive validation including:
+ * - Required fields (requestId, circuit, callbackUrl)
+ * - Circuit type validity (must be a supported circuit)
+ * - Circuit-specific input validation (e.g., userAddress format, countryList structure)
+ * - Expiration check (if expiresAt is provided)
+ *
+ * Note: userAddress is optional for both circuits - the mobile app will prompt
+ * for wallet connection if not provided.
+ *
+ * @param request - Proof request to validate
+ * @returns Validation result with `valid` flag and optional `error` message
+ */
 function validateProofRequest(request) {
     if (!request.requestId) {
         return { valid: false, error: 'Missing requestId' };
@@ -757,14 +663,6 @@ function validateProofRequest(request) {
             return { valid: false, error: 'provider must be a non-empty string when specified' };
         }
     }
-    else if (request.circuit === 'mdl_kr_ownership' ||
-        request.circuit === 'mdl_kr_age' ||
-        request.circuit === 'mdl_kr_region') {
-        const mdlError = validateMdlInputs(request.circuit, request.inputs);
-        if (mdlError) {
-            return { valid: false, error: mdlError };
-        }
-    }
     // The action, decided by the circuit's own entry rather than by naming a
     // circuit here, so every action-capable circuit is checked the same way.
     {
@@ -1001,7 +899,7 @@ function estimateQRDataSize(requestOrUrl, scheme = DEFAULT_SCHEME) {
  *   The version. `@aztec/bb.js` must be the WASM build of the same bb the
  *   circuits are compiled with -- `BB_VERSION` in circuits/toolchain.env,
  *   4.2.0-aztecnr-rc.2 since the beta.19 toolchain. Versions are not
- *   interchangeable: on the Korea Mobile ID age circuit the 2025 nightly wrote
+ *   interchangeable: on one of our circuits the 2025 nightly wrote
  *   a 16256-byte proof where bb 1.2.0 wrote 16224 for the identical circuit and
  *   witness, with the SAME verification key, so the key cannot warn you. A
  *   mismatch shows up only as verification failing.
@@ -1103,15 +1001,12 @@ function normalisePublicInputs(publicInputs) {
  *
  * @internal
  */
-async function fetchVerificationKey(circuit, timeoutMs) {
-    const cached = vkCache.get(circuit);
+async function fetchVerificationKey(circuit, variant, timeoutMs) {
+    const cacheKey = `${circuit}/${variant}`;
+    const cached = vkCache.get(cacheKey);
     if (cached && Date.now() - cached.at < VK_CACHE_TTL_MS)
         return cached.vk;
-    const vkPath = circuits.CIRCUIT_VK_PATHS[circuit];
-    if (!vkPath) {
-        throw new Error(`No verification key path for circuit '${circuit}'. ` +
-            `Add it to CIRCUIT_VK_PATHS, or pass verificationKey directly.`);
-    }
+    const vkPath = circuits.getCircuitPackage(circuit, variant).vkPath;
     const url = `${CIRCUITS_VK_BASE}/${vkPath}`;
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), timeoutMs);
@@ -1128,7 +1023,7 @@ async function fetchVerificationKey(circuit, timeoutMs) {
             throw new Error(`The verification key at ${url} is ${vk.length} bytes, far too small to be one. ` +
                 `The path is probably wrong and something else was served.`);
         }
-        vkCache.set(circuit, { vk, at: Date.now() });
+        vkCache.set(cacheKey, { vk, at: Date.now() });
         return vk;
     }
     finally {
@@ -1141,9 +1036,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)
@@ -1166,12 +1063,16 @@ async function verifyProofOffChain(circuit, proof, publicInputs, options = {}) {
     if (!circuits.isCircuitId(circuit)) {
         return { valid: false, error: `Unknown circuit '${circuit}'. Known: ${circuits.ALL_CIRCUIT_IDS.join(', ')}.` };
     }
+    const signer = circuits.resolveSignerVariant(circuit, options.signerVariant, proof);
+    if ('error' in signer) {
+        return { valid: false, error: signer.error };
+    }
     // Before Barretenberg, and for the same reason as on-chain: a proof can be
     // mathematically valid and still mean nothing, because some circuits take
     // 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 core.checkProofIssuer(circuit, publicInputs);
+    const issuer = await core.checkProofIssuer(circuit, publicInputs, { request: options.request });
     if (!issuer.ok) {
         return { valid: false, error: issuer.error };
     }
@@ -1212,7 +1113,7 @@ async function verifyProofOffChain(circuit, proof, publicInputs, options = {}) {
         // relay can deliver a short value (`0x01`), and the check below must see
         // exactly what the circuit committed to.
         const fields = normalisePublicInputs(publicInputs);
-        const vk = options.verificationKey ?? (await fetchVerificationKey(circuit, timeoutMs));
+        const vk = options.verificationKey ?? (await fetchVerificationKey(circuit, signer.variant, timeoutMs));
         const barretenberg = await bb.Barretenberg.new({ threads: 1 });
         api = barretenberg;
         const verifier = new bb.UltraHonkVerifierBackend(barretenberg);
@@ -1246,6 +1147,17 @@ const RELAY_TERMINAL_STATUSES = ['completed', 'error', 'failed', 'cancelled', 'e
 function isTerminalRelayStatus(status) {
     return RELAY_TERMINAL_STATUSES.includes(status);
 }
+/**
+ * How long `waitForProof()` / `waitForResult()` wait when the caller passes no
+ * `timeoutMs`: 600 000 ms (10 min).
+ *
+ * The relay answers `expired` itself at 540 s, so with this default a dApp
+ * always gets a terminal status to branch on rather than its own timeout. A
+ * heavy proof on an older phone takes a few minutes after the user confirms;
+ * the earlier 300 000 ms default could fire while such a proof was still being
+ * made.
+ */
+const DEFAULT_RELAY_WAIT_MS = 600000;
 
 /**
  * Proofport SDK - Main class
@@ -1313,6 +1225,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;
         /**
@@ -1389,7 +1308,7 @@ class ProofportSDK {
         const request = {
             requestId: generateRequestId(),
             // The circuit asked for, always. This used to be the literal
-            // 'coinbase_attestation', and every circuit that was not country or mDL
+            // 'coinbase_attestation', and every circuit that was not country
             // was routed here -- a GIWA, Dojang or OIDC request silently became a
             // Coinbase KYC request.
             circuit,
@@ -1496,45 +1415,10 @@ class ProofportSDK {
         switch (builder) {
             case 'country':
                 return this.createCoinbaseCountryRequest(inputs, options);
-            case 'mdl':
-                return this.createMdlKrRequest(circuit, inputs, options);
             case 'scoped':
                 return this.createScopedRequest(circuit, inputs, options);
         }
     }
-    /**
-     * @internal
-     * Creates a Korea Mobile ID (mDL) proof request for any of the three
-     * mDL predicate circuits (ownership / age / region).
-     *
-     * The mobile app collects the license data on-device; the dapp only
-     * supplies the predicate parameters validated here. No wallet signature
-     * is required for mDL circuits.
-     *
-     * @param circuit - 'mdl_kr_ownership' | 'mdl_kr_age' | 'mdl_kr_region'
-     * @param inputs - Predicate inputs (see MdlKr*Inputs types)
-     * @param options - Request configuration options
-     *
-     * @throws Error if the predicate inputs fail validation
-     */
-    createMdlKrRequest(circuit, inputs, options = {}) {
-        const mdlError = validateMdlInputs(circuit, inputs);
-        if (mdlError) {
-            throw new Error(`${mdlError} (circuit: ${circuit})`);
-        }
-        const request = {
-            requestId: generateRequestId(),
-            circuit,
-            inputs,
-            message: options.message,
-            dappName: options.dappName,
-            dappIcon: options.dappIcon,
-            createdAt: Date.now(),
-            expiresAt: Date.now() + (options.expiresInMs || DEFAULT_REQUEST_EXPIRY_MS),
-        };
-        this.pendingRequests.set(request.requestId, request);
-        return request;
-    }
     // ============ Deep Link Generation ============
     /**
      * @internal
@@ -1874,9 +1758,50 @@ class ProofportSDK {
      * }
      * ```
      */
-    async verifyOnChain(circuit, proof, publicInputs, providerOrSigner) {
+    async verifyOnChain(circuit, proof, publicInputs, providerOrSigner, options = {}) {
         const parsedProof = core.parseProofForOnChain(proof, publicInputs, publicInputs.length);
-        return core.verifyProofOnChain(circuit, parsedProof, providerOrSigner, this.verifierTarget(circuit));
+        return core.verifyProofOnChain(circuit, parsedProof, providerOrSigner, this.verifierTarget(circuit), undefined, {
+            request: options.request,
+            signerVariant: options.signerVariant,
+        });
+    }
+    /**
+     * 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
@@ -1903,6 +1828,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
      *
@@ -1929,10 +1857,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 = core.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
@@ -1941,7 +1876,7 @@ class ProofportSDK {
         return core.verifyProofOnChain(response.circuit, parsedProof, providerOrSigner, this.verifierTarget(response.circuit), {
             verifierAddress: response.verifierAddress,
             chainId: response.chainId,
-        });
+        }, { request, signerVariant: response.signerVariant });
     }
     /**
      * Verifies a proof response off-chain, against the circuit's verification key.
@@ -1971,7 +1906,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, signerVariant: response.signerVariant });
     }
     // ============ Utility Methods ============
     /**
@@ -2329,14 +2271,6 @@ class ProofportSDK {
         if (needsSignature && !this.signer) {
             throw new Error('Signer not set. Call setSigner() first. Wallet signature is required for this circuit.');
         }
-        // mDL circuits: validate predicate inputs client-side before hitting the
-        // relay, so a bad ageThreshold / targetRegion fails fast with a clear error.
-        if (circuit === 'mdl_kr_ownership' || circuit === 'mdl_kr_age' || circuit === 'mdl_kr_region') {
-            const mdlError = validateMdlInputs(circuit, inputs);
-            if (mdlError) {
-                throw new Error(`${mdlError} (circuit: ${circuit})`);
-            }
-        }
         // The action, per the circuit's entry in CIRCUIT_ACTION_BINDING. Checked
         // here, before a challenge is burned, because the alternative is a refusal
         // from inside the mobile app -- a screen the dapp developer never sees,
@@ -2410,7 +2344,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.
@@ -2450,14 +2386,14 @@ class ProofportSDK {
      * @param requestId - The relay-issued request ID
      * @param options - Polling options
      * @param options.intervalMs - Polling interval in milliseconds (default: 2000)
-     * @param options.timeoutMs - Maximum polling time in milliseconds (default: 300000 = 5 min)
+     * @param options.timeoutMs - Maximum polling time in milliseconds (default: 600000 = 10 min, `DEFAULT_RELAY_WAIT_MS`)
      * @param options.onStatusChange - Callback when status changes
      * @returns Promise resolving to final RelayProofResult
      * @throws Error if timeout or relay error
      */
     async waitForResult(requestId, options = {}) {
         const interval = options.intervalMs || 2000;
-        const timeout = options.timeoutMs || 300000;
+        const timeout = options.timeoutMs || DEFAULT_RELAY_WAIT_MS;
         const startTime = Date.now();
         let lastStatus = '';
         while (Date.now() - startTime < timeout) {
@@ -2569,12 +2505,12 @@ class ProofportSDK {
      *
      * @param requestId - The relay-issued request ID
      * @param options - Configuration options
-     * @param options.timeoutMs - Maximum wait time in ms (default: 300000 = 5 min)
+     * @param options.timeoutMs - Maximum wait time in ms (default: 600000 = 10 min, `DEFAULT_RELAY_WAIT_MS`)
      * @param options.onStatusChange - Callback for status updates
      * @returns Promise resolving to final RelayProofResult
      */
     async waitForProof(requestId, options = {}) {
-        const timeout = options.timeoutMs || 300000;
+        const timeout = options.timeoutMs || DEFAULT_RELAY_WAIT_MS;
         // Try Socket.IO first
         if (this.relayUrl) {
             try {
@@ -2693,6 +2629,8 @@ class ProofportSDK {
         return core.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
@@ -2704,9 +2642,6 @@ ProofportSDK.REQUEST_BUILDERS = {
     oidc_domain_attestation: 'scoped',
     giwa_attestation: 'scoped',
     dojang_playground: 'scoped',
-    mdl_kr_ownership: 'mdl',
-    mdl_kr_age: 'mdl',
-    mdl_kr_region: 'mdl',
 };
 
 Object.defineProperty(exports, "COINBASE_ATTESTATION_PUBLIC_INPUT_LAYOUT", {
@@ -2717,18 +2652,50 @@ Object.defineProperty(exports, "COINBASE_COUNTRY_PUBLIC_INPUT_LAYOUT", {
     enumerable: true,
     get: function () { return core.COINBASE_COUNTRY_PUBLIC_INPUT_LAYOUT; }
 });
-Object.defineProperty(exports, "MDL_KR_PUBLIC_INPUT_LAYOUT", {
+Object.defineProperty(exports, "OIDC_ALLOWED_AUDIENCES", {
     enumerable: true,
-    get: function () { return core.MDL_KR_PUBLIC_INPUT_LAYOUT; }
+    get: function () { return core.OIDC_ALLOWED_AUDIENCES; }
 });
 Object.defineProperty(exports, "OIDC_DOMAIN_ATTESTATION_PUBLIC_INPUT_LAYOUT", {
     enumerable: true,
     get: function () { return core.OIDC_DOMAIN_ATTESTATION_PUBLIC_INPUT_LAYOUT; }
 });
+Object.defineProperty(exports, "OIDC_NONCE_DOMAIN", {
+    enumerable: true,
+    get: function () { return core.OIDC_NONCE_DOMAIN; }
+});
+Object.defineProperty(exports, "OIDC_NOW_MAX_AGE_SECONDS", {
+    enumerable: true,
+    get: function () { return core.OIDC_NOW_MAX_AGE_SECONDS; }
+});
+Object.defineProperty(exports, "OIDC_NOW_MAX_FUTURE_SECONDS", {
+    enumerable: true,
+    get: function () { return core.OIDC_NOW_MAX_FUTURE_SECONDS; }
+});
+Object.defineProperty(exports, "OIDC_V1_PUBLIC_INPUT_COUNT", {
+    enumerable: true,
+    get: function () { return core.OIDC_V1_PUBLIC_INPUT_COUNT; }
+});
+Object.defineProperty(exports, "OIDC_V2_PUBLIC_INPUT_COUNT", {
+    enumerable: true,
+    get: function () { return core.OIDC_V2_PUBLIC_INPUT_COUNT; }
+});
+Object.defineProperty(exports, "PINNED_VARIANT_VERIFIERS", {
+    enumerable: true,
+    get: function () { return core.PINNED_VARIANT_VERIFIERS; }
+});
 Object.defineProperty(exports, "PINNED_VERIFIERS", {
     enumerable: true,
     get: function () { return core.PINNED_VERIFIERS; }
 });
+Object.defineProperty(exports, "checkOidcPolicy", {
+    enumerable: true,
+    get: function () { return core.checkOidcPolicy; }
+});
+Object.defineProperty(exports, "deriveOidcNonceBinding", {
+    enumerable: true,
+    get: function () { return core.deriveOidcNonceBinding; }
+});
 Object.defineProperty(exports, "extractDomainFromPublicInputs", {
     enumerable: true,
     get: function () { return core.extractDomainFromPublicInputs; }
@@ -2741,10 +2708,18 @@ Object.defineProperty(exports, "extractScopeFromPublicInputs", {
     enumerable: true,
     get: function () { return core.extractScopeFromPublicInputs; }
 });
+Object.defineProperty(exports, "getPinnedVariantVerifier", {
+    enumerable: true,
+    get: function () { return core.getPinnedVariantVerifier; }
+});
 Object.defineProperty(exports, "getPinnedVerifier", {
     enumerable: true,
     get: function () { return core.getPinnedVerifier; }
 });
+Object.defineProperty(exports, "oidcAudienceHash", {
+    enumerable: true,
+    get: function () { return core.oidcAudienceHash; }
+});
 Object.defineProperty(exports, "ALL_CIRCUIT_IDS", {
     enumerable: true,
     get: function () { return circuits.ALL_CIRCUIT_IDS; }
@@ -2757,6 +2732,10 @@ Object.defineProperty(exports, "CIRCUIT_IDS", {
     enumerable: true,
     get: function () { return circuits.CIRCUIT_IDS; }
 });
+Object.defineProperty(exports, "CIRCUIT_PACKAGES", {
+    enumerable: true,
+    get: function () { return circuits.CIRCUIT_PACKAGES; }
+});
 Object.defineProperty(exports, "CIRCUIT_SUPPORT_STATUS", {
     enumerable: true,
     get: function () { return circuits.CIRCUIT_SUPPORT_STATUS; }
@@ -2773,6 +2752,10 @@ Object.defineProperty(exports, "PLANNED_CIRCUIT_IDS", {
     enumerable: true,
     get: function () { return circuits.PLANNED_CIRCUIT_IDS; }
 });
+Object.defineProperty(exports, "SIGNER_VARIANTS", {
+    enumerable: true,
+    get: function () { return circuits.SIGNER_VARIANTS; }
+});
 Object.defineProperty(exports, "SUPPORTED_CIRCUIT_IDS", {
     enumerable: true,
     get: function () { return circuits.SUPPORTED_CIRCUIT_IDS; }
@@ -2781,6 +2764,14 @@ Object.defineProperty(exports, "circuitActionBinding", {
     enumerable: true,
     get: function () { return circuits.circuitActionBinding; }
 });
+Object.defineProperty(exports, "evmProofByteLength", {
+    enumerable: true,
+    get: function () { return circuits.evmProofByteLength; }
+});
+Object.defineProperty(exports, "getCircuitPackage", {
+    enumerable: true,
+    get: function () { return circuits.getCircuitPackage; }
+});
 Object.defineProperty(exports, "getCircuitSupportStatus", {
     enumerable: true,
     get: function () { return circuits.getCircuitSupportStatus; }
@@ -2789,10 +2780,22 @@ Object.defineProperty(exports, "isCircuitId", {
     enumerable: true,
     get: function () { return circuits.isCircuitId; }
 });
+Object.defineProperty(exports, "isSignerVariant", {
+    enumerable: true,
+    get: function () { return circuits.isSignerVariant; }
+});
 Object.defineProperty(exports, "isSupportedCircuitId", {
     enumerable: true,
     get: function () { return circuits.isSupportedCircuitId; }
 });
+Object.defineProperty(exports, "resolveSignerVariant", {
+    enumerable: true,
+    get: function () { return circuits.resolveSignerVariant; }
+});
+Object.defineProperty(exports, "signerVariantsOf", {
+    enumerable: true,
+    get: function () { return circuits.signerVariantsOf; }
+});
 Object.defineProperty(exports, "parseTypedAction", {
     enumerable: true,
     get: function () { return typedAction.parseTypedAction; }
@@ -2801,6 +2804,7 @@ Object.defineProperty(exports, "validateTypedAction", {
     enumerable: true,
     get: function () { return typedAction.validateTypedAction; }
 });
+exports.DEFAULT_RELAY_WAIT_MS = DEFAULT_RELAY_WAIT_MS;
 exports.ProofportSDK = ProofportSDK;
 exports.RELAY_TERMINAL_STATUSES = RELAY_TERMINAL_STATUSES;
 exports.default = ProofportSDK;