@zkproofport-app/sdk 0.5.0-beta.5 → 0.5.0-beta.6

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, 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_VARIANT_VERIFIERS, PINNED_VERIFIERS, checkOidcPolicy, deriveOidcNonceBinding, extractDomainFromPublicInputs, extractNullifierFromPublicInputs, extractScopeFromPublicInputs, getPinnedVariantVerifier, getPinnedVerifier, oidcAudienceHash } from '@zkproofport-app/core';
+import { countryListError, checkProofIssuer, parseProofForOnChain, verifyProofOnChain, getPinnedVerifier, extractScopeFromPublicInputs, extractNullifierFromPublicInputs, extractDomainFromPublicInputs } from '@zkproofport-app/core';
+export { COINBASE_ATTESTATION_PUBLIC_INPUT_LAYOUT, COINBASE_COUNTRY_PUBLIC_INPUT_COUNT, COINBASE_COUNTRY_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_VARIANT_VERIFIERS, PINNED_VERIFIERS, checkOidcPolicy, deriveOidcNonceBinding, extractDomainFromPublicInputs, extractNullifierFromPublicInputs, extractScopeFromPublicInputs, getPinnedVariantVerifier, getPinnedVerifier, oidcAudienceHash } from '@zkproofport-app/core';
 import { isCircuitId, ALL_CIRCUIT_IDS, circuitActionBinding, resolveSignerVariant, getCircuitPackage, CIRCUIT_NEEDS_WALLET_SIGNATURE } from '@zkproofport-app/core/circuits';
 export { ALL_CIRCUIT_IDS, CIRCUIT_ACTION_BINDING, CIRCUIT_IDS, CIRCUIT_PACKAGES, CIRCUIT_SUPPORT_STATUS, CIRCUIT_VK_PATHS, EXPERIMENTAL_CIRCUIT_IDS, PLANNED_CIRCUIT_IDS, SIGNER_VARIANTS, SUPPORTED_CIRCUIT_IDS, circuitActionBinding, evmProofByteLength, getCircuitPackage, getCircuitSupportStatus, isCircuitId, isSignerVariant, isSupportedCircuitId, resolveSignerVariant, signerVariantsOf } from '@zkproofport-app/core/circuits';
 import { validateTypedAction } from '@zkproofport-app/core/typedAction';
@@ -107,11 +107,15 @@ const CIRCUIT_METADATA = {
     },
     coinbase_country_attestation: {
         name: 'Coinbase Country',
-        description: 'Prove Coinbase country verification',
-        // 32 + 32 + (10 x 2) + 1 + 1 + 32 + 32 = 150, counted off
-        // coinbase-country-attestation/src/main.nr. Read 14 until 2026-09-04.
-        publicInputsCount: 150,
-        publicInputNames: ['signal_hash', 'signer_list_merkle_root', 'country_list', 'country_list_length', 'is_included'],
+        description: 'Prove Coinbase country verification, optionally authorizing one EIP-712 action',
+        // Coinbase Country v2 (coinbase-country-attestation-v2/src/main.nr):
+        // signal_hash 0-31, domain_separator 32-63, action_hash 64-95,
+        // signer_list_merkle_root 96-127, country_list 128-147 (10 x 2 bytes),
+        // country_list_length 148, is_included 149, scope 150-181,
+        // nullifier 182-213, attested_at 214 = 215 fields. v1's 150 fields are
+        // refused on every verify path.
+        publicInputsCount: 215,
+        publicInputNames: ['signal_hash', 'domain_separator', 'action_hash', 'signer_list_merkle_root', 'country_list', 'country_list_length', 'is_included', 'scope', 'nullifier', 'attested_at'],
     },
     oidc_domain_attestation: {
         name: 'OIDC Domain',
@@ -640,11 +644,9 @@ function validateProofRequest(request) {
         if (inputs.userAddress && !/^0x[a-fA-F0-9]{40}$/.test(inputs.userAddress)) {
             return { valid: false, error: 'Invalid userAddress format' };
         }
-        if (!inputs.countryList || !Array.isArray(inputs.countryList) || inputs.countryList.length === 0) {
-            return { valid: false, error: 'countryList is required and must be a non-empty array' };
-        }
-        if (!inputs.countryList.every(c => typeof c === 'string')) {
-            return { valid: false, error: 'countryList must contain only strings' };
+        const listError = countryListError(inputs.countryList);
+        if (listError) {
+            return { valid: false, error: listError };
         }
         if (typeof inputs.isIncluded !== 'boolean') {
             return { valid: false, error: 'isIncluded is required and must be a boolean' };
@@ -3938,7 +3940,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, { request: options.request });
+    const issuer = await checkProofIssuer(circuit, publicInputs, { request: options.request, countryCondition: options.countryCondition });
     if (!issuer.ok) {
         return { valid: false, error: issuer.error };
     }
@@ -4098,6 +4100,12 @@ class ProofportSDK {
          * {@link ProofportSDK.MAX_REMEMBERED_RELAY_REQUESTS}.
          */
         this.relayRequests = new Map();
+        /**
+         * requestId -> the country list and direction of the Coinbase Country relay
+         * requests this instance created, so verifyResponse* can hold the proof to
+         * them. Bounded like {@link relayRequests}.
+         */
+        this.countryRequests = new Map();
         this.signer = null;
         this.socket = null;
         /**
@@ -4229,6 +4237,15 @@ class ProofportSDK {
         if (typeof inputs.isIncluded !== 'boolean') {
             throw new Error('isIncluded is required for coinbase_country_attestation circuit');
         }
+        const listError = countryListError(inputs.countryList);
+        if (listError)
+            throw new Error(`${listError} (circuit: coinbase_country_attestation)`);
+        // Coinbase Country v2 binds an action or none, like Coinbase KYC v2.
+        if (inputs.action !== undefined) {
+            const actionError = validateTypedAction(inputs.action);
+            if (actionError)
+                throw new Error(`${actionError} (circuit: coinbase_country_attestation)`);
+        }
         const request = {
             requestId: generateRequestId(),
             circuit: 'coinbase_country_attestation',
@@ -4629,6 +4646,7 @@ class ProofportSDK {
         return verifyProofOnChain(circuit, parsedProof, providerOrSigner, this.verifierTarget(circuit), undefined, {
             request: options.request,
             signerVariant: options.signerVariant,
+            countryCondition: options.countryCondition,
         });
     }
     /**
@@ -4669,6 +4687,43 @@ class ProofportSDK {
             this.relayRequests.delete(oldest);
         }
     }
+    /**
+     * The country list and direction a `coinbase_country_attestation` response
+     * must have been proved against: the one the caller passed, else the relay
+     * request this instance created under the response's requestId, else the
+     * deep-link request still pending under it. `{ error }` when there is none:
+     * the proof's list is the prover's choice, so a response this SDK cannot
+     * place is refused rather than accepted for whatever list it carries.
+     */
+    countryConditionFor(response, explicit) {
+        if (explicit !== undefined)
+            return { condition: explicit };
+        const remembered = this.countryRequests.get(response.requestId);
+        if (remembered)
+            return { condition: remembered };
+        const pending = this.pendingRequests.get(response.requestId);
+        const inputs = pending?.circuit === 'coinbase_country_attestation' ? pending.inputs : undefined;
+        if (inputs && Array.isArray(inputs.countryList) && typeof inputs.isIncluded === 'boolean') {
+            return { condition: { countryList: [...inputs.countryList], isIncluded: inputs.isIncluded } };
+        }
+        return {
+            error: `No Coinbase Country request ${JSON.stringify(response.requestId)} was created by this SDK instance, so the ` +
+                "proof's country list cannot be checked against what was asked. Pass { countryCondition: { countryList, " +
+                'isIncluded } } -- the list and direction of the request you created.',
+        };
+    }
+    /** @internal Remember a Coinbase Country relay request's list and direction for verifyResponse*. */
+    rememberCountryRequest(requestId, inputs) {
+        const i = inputs;
+        if (typeof requestId !== 'string' || !i || !Array.isArray(i.countryList) || typeof i.isIncluded !== 'boolean')
+            return;
+        this.countryRequests.delete(requestId);
+        this.countryRequests.set(requestId, { countryList: [...i.countryList], isIncluded: i.isIncluded });
+        while (this.countryRequests.size > ProofportSDK.MAX_REMEMBERED_RELAY_REQUESTS) {
+            const oldest = this.countryRequests.keys().next().value;
+            this.countryRequests.delete(oldest);
+        }
+    }
     /**
      * The verifier for a circuit: the one the dApp configured, otherwise the
      * pinned deployment on the chain this SDK's environment verifies that
@@ -4697,6 +4752,10 @@ class ProofportSDK {
      * @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.
+     * @param options.countryCondition - For `coinbase_country_attestation`: the
+     *   `{ countryList, isIncluded }` the request asked for. Not needed for a
+     *   request this SDK instance created (relay or deep link); a Country response
+     *   this instance cannot place is refused without it.
      *
      * @returns Promise resolving to verification result with valid boolean and optional error message
      *
@@ -4734,6 +4793,13 @@ class ProofportSDK {
                 return { valid: false, error: found.error };
             request = found.request;
         }
+        let countryCondition;
+        if (response.circuit === 'coinbase_country_attestation') {
+            const found = this.countryConditionFor(response, options.countryCondition);
+            if ('error' in found)
+                return { valid: false, error: found.error };
+            countryCondition = found.condition;
+        }
         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
@@ -4742,7 +4808,7 @@ class ProofportSDK {
         return verifyProofOnChain(response.circuit, parsedProof, providerOrSigner, this.verifierTarget(response.circuit), {
             verifierAddress: response.verifierAddress,
             chainId: response.chainId,
-        }, { request, signerVariant: response.signerVariant });
+        }, { request, signerVariant: response.signerVariant, countryCondition });
     }
     /**
      * Verifies a proof response off-chain, against the circuit's verification key.
@@ -4779,7 +4845,14 @@ class ProofportSDK {
                 return { valid: false, error: found.error };
             request = found.request;
         }
-        return verifyProofOffChain(response.circuit, response.proof, response.publicInputs, { ...options, request, signerVariant: response.signerVariant });
+        let countryCondition;
+        if (response.circuit === 'coinbase_country_attestation') {
+            const found = this.countryConditionFor(response, options?.countryCondition);
+            if ('error' in found)
+                return { valid: false, error: found.error };
+            countryCondition = found.condition;
+        }
+        return verifyProofOffChain(response.circuit, response.proof, response.publicInputs, { ...options, request, countryCondition, signerVariant: response.signerVariant });
     }
     // ============ Utility Methods ============
     /**
@@ -5157,6 +5230,16 @@ class ProofportSDK {
                 }
             }
         }
+        // A Coinbase Country list the circuit would refuse is refused here, before a
+        // challenge is burned, as createProofRequest does.
+        if (circuit === 'coinbase_country_attestation') {
+            const c = inputs;
+            const listError = countryListError(c.countryList);
+            if (listError)
+                throw new Error(`${listError} (circuit: ${circuit})`);
+            if (typeof c.isIncluded !== 'boolean')
+                throw new Error('isIncluded is required for coinbase_country_attestation circuit');
+        }
         // Return target: validated before we burn a challenge, so a typo surfaces
         // as a local error instead of a relay 400 on the second round trip.
         if (options.returnScheme !== undefined) {
@@ -5212,6 +5295,8 @@ class ProofportSDK {
         }
         const created = await response.json();
         this.rememberRelayRequest(created.requestId, scope);
+        if (circuit === 'coinbase_country_attestation')
+            this.rememberCountryRequest(created.requestId, inputs);
         return created;
     }
     /**