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

package/dist/index.js

@@ -109,11 +109,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',
@@ -642,11 +646,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 = core.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' };
@@ -1073,7 +1075,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 core.checkProofIssuer(circuit, publicInputs, { request: options.request });
+    const issuer = await core.checkProofIssuer(circuit, publicInputs, { request: options.request, countryCondition: options.countryCondition });
     if (!issuer.ok) {
         return { valid: false, error: issuer.error };
     }
@@ -1233,6 +1235,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;
         /**
@@ -1364,6 +1372,15 @@ class ProofportSDK {
         if (typeof inputs.isIncluded !== 'boolean') {
             throw new Error('isIncluded is required for coinbase_country_attestation circuit');
         }
+        const listError = core.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 = typedAction.validateTypedAction(inputs.action);
+            if (actionError)
+                throw new Error(`${actionError} (circuit: coinbase_country_attestation)`);
+        }
         const request = {
             requestId: generateRequestId(),
             circuit: 'coinbase_country_attestation',
@@ -1764,6 +1781,7 @@ class ProofportSDK {
         return core.verifyProofOnChain(circuit, parsedProof, providerOrSigner, this.verifierTarget(circuit), undefined, {
             request: options.request,
             signerVariant: options.signerVariant,
+            countryCondition: options.countryCondition,
         });
     }
     /**
@@ -1804,6 +1822,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
@@ -1832,6 +1887,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
      *
@@ -1869,6 +1928,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 = 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
@@ -1877,7 +1943,7 @@ class ProofportSDK {
         return core.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.
@@ -1914,7 +1980,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 ============
     /**
@@ -2292,6 +2365,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 = core.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) {
@@ -2347,6 +2430,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;
     }
     /**
@@ -2649,6 +2734,10 @@ Object.defineProperty(exports, "COINBASE_ATTESTATION_PUBLIC_INPUT_LAYOUT", {
     enumerable: true,
     get: function () { return core.COINBASE_ATTESTATION_PUBLIC_INPUT_LAYOUT; }
 });
+Object.defineProperty(exports, "COINBASE_COUNTRY_PUBLIC_INPUT_COUNT", {
+    enumerable: true,
+    get: function () { return core.COINBASE_COUNTRY_PUBLIC_INPUT_COUNT; }
+});
 Object.defineProperty(exports, "COINBASE_COUNTRY_PUBLIC_INPUT_LAYOUT", {
     enumerable: true,
     get: function () { return core.COINBASE_COUNTRY_PUBLIC_INPUT_LAYOUT; }