@zkpassport/sdk 0.2.4 → 0.2.6

package/README.md

@@ -15,21 +15,21 @@ npm install @zkpassport/sdk
 ## How to use
 
 ```ts
-import { ZKPassport, EU_COUNTRIES } from '@zkpassport/sdk'
+import { ZKPassport, EU_COUNTRIES } from "@zkpassport/sdk"
 
 // Replace with your domain
-const zkPassport = new ZKPassport('demo.zkpassport.id')
+const zkPassport = new ZKPassport("demo.zkpassport.id")
 
 // Specify your app name, logo and the purpose of the request
 // you'll send to your visitors or users
 const queryBuilder = await zkPassport.request({
-  name: 'ZKPassport',
-  logo: 'https://zkpassport.id/logo.png',
-  purpose: 'Prove you are an adult from the EU but not from Scandinavia',
+  name: "ZKPassport",
+  logo: "https://zkpassport.id/logo.png",
+  purpose: "Prove you are an adult from the EU but not from Scandinavia",
   // The scope is optional and can be used to scope the unique identifier
   // of the request to a specific use case
   // By default, the request's unique identifier is scoped to your domain name only
-  scope: 'eu-adult-not-scandinavia',
+  scope: "eu-adult-not-scandinavia",
 })
 
 // Specify the data you want to disclose
@@ -47,10 +47,10 @@ const {
   onReject,
   onError,
 } = queryBuilder
-  .disclose('firstname')
-  .gte('age', 18)
-  .in('nationality', EU_COUNTRIES)
-  .out('nationality', ['Sweden', 'Denmark'])
+  .disclose("firstname")
+  .gte("age", 18)
+  .in("nationality", EU_COUNTRIES)
+  .out("nationality", ["Sweden", "Denmark"])
   .done()
 
 // Generate a QR Code with the url and let your user scan it
@@ -60,12 +60,12 @@ onRequestReceived(() => {
   // The user scanned the QR code or clicked the link to the request
   // Essentially, this means the request popup is now opened
   // on the user phone
-  console.log('Request received')
+  console.log("Request received")
 })
 
 onGeneratingProof(() => {
   // The user accepted the request and the proof is being generated
-  console.log('Generating proof')
+  console.log("Generating proof")
 })
 
 // You probably don't need to use this callback
@@ -75,10 +75,10 @@ onProofGenerated(({ proof, vkeyHash, version, name }: ProofResult) => {
   // Here, you can retrieve the proof manually and verify it
   // But note that the verification of the proofs is handled
   // automatically by the SDK
-  console.log('Proof generated', proof)
-  console.log('Verification key hash', vkeyHash)
-  console.log('Version', version)
-  console.log('Name', name)
+  console.log("Proof generated", proof)
+  console.log("Verification key hash", vkeyHash)
+  console.log("Version", version)
+  console.log("Name", name)
 })
 
 // That's the callback you're looking for
@@ -93,22 +93,22 @@ onResult(
     result: QueryResult
   }) => {
     // All the proofs have been generated and the final result is available
-    console.log('firstname', result.firstname.disclose.result)
-    console.log('age over 18', result.age.gte.result)
-    console.log('nationality in EU', result.nationality.in.result)
-    console.log('nationality not from Scandinavia', result.nationality.out.result)
+    console.log("firstname", result.firstname.disclose.result)
+    console.log("age over 18", result.age.gte.result)
+    console.log("nationality in EU", result.nationality.in.result)
+    console.log("nationality not from Scandinavia", result.nationality.out.result)
     // You can also retrieved what were the values originally requested
-    console.log('age over', result.age.gte.expected)
-    console.log('nationality in', result.nationality.in.expected)
-    console.log('nationality not in', result.nationality.out.expected)
+    console.log("age over", result.age.gte.expected)
+    console.log("nationality in", result.nationality.in.expected)
+    console.log("nationality not in", result.nationality.out.expected)
     // You can make sure the proof are valid by checking verified is set to true
-    console.log('proofs are valid', verified)
+    console.log("proofs are valid", verified)
     // You can also retrieve the unique identifier associated to this request
     // The assumption is that the unique identifier will be the same if coming
     // from the same ID for the same domain name and scope
     // So you can use it to identify if the user has already provided the proof
     // for this specific use case
-    console.log('unique identifier', uniqueIdentifier)
+    console.log("unique identifier", uniqueIdentifier)
   },
 )
 ```
@@ -122,17 +122,17 @@ You can integrate `@zkpassport/sdk` into a Next.js application by creating a bac
 **App Router:** `app/api/zkpassport/route.ts`
 
 ```typescript
-import { NextResponse } from 'next/server'
-import { ZKPassport } from '@zkpassport/sdk'
+import { NextResponse } from "next/server"
+import { ZKPassport } from "@zkpassport/sdk"
 
 export async function GET() {
-  const zkPassport = new ZKPassport('demo.zkpassport.id') // Replace with your domain
+  const zkPassport = new ZKPassport("demo.zkpassport.id") // Replace with your domain
   const queryBuilder = await zkPassport.request({
-    name: 'ZKPassport Demo',
-    logo: 'https://via.placeholder.com/150',
-    purpose: 'Verify user nationality and first name',
+    name: "ZKPassport Demo",
+    logo: "https://via.placeholder.com/150",
+    purpose: "Verify user nationality and first name",
   })
-  const { url } = queryBuilder.disclose('nationality').disclose('firstname').done()
+  const { url } = queryBuilder.disclose("nationality").disclose("firstname").done()
   return NextResponse.json({ url })
 }
 ```
@@ -142,14 +142,14 @@ export async function GET() {
 **App Router:** `app/page.tsx`
 
 ```tsx
-'use client'
-import { useEffect, useState } from 'react'
+"use client"
+import { useEffect, useState } from "react"
 
 export default function Home() {
   const [verificationUrl, setVerificationUrl] = useState<string | null>(null)
 
   useEffect(() => {
-    fetch('/api/zkpassport')
+    fetch("/api/zkpassport")
       .then((res) => res.json())
       .then((data) => setVerificationUrl(data.url))
       .catch(console.error)

package/dist/cjs/encryption.d.ts

@@ -1,7 +1,7 @@
 export declare function generateECDHKeyPair(): Promise<{
-    privateKey: Uint8Array;
-    publicKey: Uint8Array;
+    privateKey: import("@noble/secp256k1").Bytes;
+    publicKey: import("@noble/secp256k1").Bytes;
 }>;
-export declare function getSharedSecret(privateKey: string, publicKey: string): Promise<Uint8Array>;
-export declare function encrypt(message: string, sharedSecret: Uint8Array, topic: string): Promise<Uint8Array>;
+export declare function getSharedSecret(privateKey: string, publicKey: string): Promise<Uint8Array<ArrayBuffer>>;
+export declare function encrypt(message: string, sharedSecret: Uint8Array, topic: string): Promise<Uint8Array<ArrayBufferLike>>;
 export declare function decrypt(ciphertext: Uint8Array, sharedSecret: Uint8Array, topic: string): Promise<string>;

package/dist/cjs/encryption.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateECDHKeyPair = generateECDHKeyPair;
 exports.getSharedSecret = getSharedSecret;

package/dist/cjs/index.d.ts

@@ -134,6 +134,8 @@ export declare class ZKPassport {
     private topicToRequestReceived;
     private topicToService;
     private topicToProofs;
+    private topicToExpectedProofCount;
+    private topicToResults;
     private onRequestReceivedCallbacks;
     private onGeneratingProofCallbacks;
     private onBridgeConnectCallbacks;
@@ -142,6 +144,8 @@ export declare class ZKPassport {
     private onRejectCallbacks;
     private onErrorCallbacks;
     constructor(_domain?: string);
+    private handleResult;
+    private setExpectedProofCount;
     /**
      * @notice Handle an encrypted message.
      * @param request The request.

package/dist/cjs/index.js

@@ -14,7 +14,26 @@ const node_gzip_1 = require("node-gzip");
 //import initNoirC from '@noir-lang/noirc_abi'
 //import initACVM from '@noir-lang/acvm_js'
 const en_json_1 = tslib_1.__importDefault(require("i18n-iso-countries/langs/en.json"));
+const buffer_1 = require("buffer/");
+// If Buffer is not defined, then we use the Buffer from the buffer package
+if (typeof globalThis.Buffer === "undefined") {
+    globalThis.Buffer = buffer_1.Buffer;
+}
 (0, i18n_iso_countries_1.registerLocale)(en_json_1.default);
+function hasRequestedAccessToField(credentialsRequest, field) {
+    const fieldValue = credentialsRequest[field];
+    const isDefined = fieldValue !== undefined && fieldValue !== null;
+    if (!isDefined) {
+        return false;
+    }
+    for (const key in fieldValue) {
+        if (fieldValue[key] !== undefined &&
+            fieldValue[key] !== null) {
+            return true;
+        }
+    }
+    return false;
+}
 function normalizeCountry(country) {
     let normalizedCountry;
     const alpha3 = (0, i18n_iso_countries_1.getAlpha3Code)(country, "en");
@@ -56,6 +75,8 @@ class ZKPassport {
         this.topicToRequestReceived = {};
         this.topicToService = {};
         this.topicToProofs = {};
+        this.topicToExpectedProofCount = {};
+        this.topicToResults = {};
         this.onRequestReceivedCallbacks = {};
         this.onGeneratingProofCallbacks = {};
         this.onBridgeConnectCallbacks = {};
@@ -74,6 +95,70 @@ class ZKPassport {
       await Promise.all([initACVM(acvm), initNoirC(noirc)])
       this.wasmVerifierInit = true
     }*/
+    async handleResult(topic) {
+        const result = this.topicToResults[topic];
+        // Clear the results straight away to avoid concurrency issues
+        delete this.topicToResults[topic];
+        // Verify the proofs and extract the unique identifier (aka nullifier) and the verification result
+        const { uniqueIdentifier, verified } = await this.verify(topic, this.topicToProofs[topic], result);
+        await Promise.all(this.onResultCallbacks[topic].map((callback) => callback({
+            uniqueIdentifier,
+            verified,
+            result,
+        })));
+        // Clear the expected proof count
+        delete this.topicToExpectedProofCount[topic];
+    }
+    setExpectedProofCount(topic) {
+        const fields = Object.keys(this.topicToConfig[topic]).filter((key) => hasRequestedAccessToField(this.topicToConfig[topic], key));
+        const neededCircuits = [];
+        // Determine which circuits are needed based on the requested fields
+        for (const field of fields) {
+            for (const key in this.topicToConfig[topic][field]) {
+                switch (key) {
+                    case "eq":
+                    case "disclose":
+                        if (field !== "age" && !neededCircuits.includes("disclose_bytes")) {
+                            neededCircuits.push("disclose_bytes");
+                        }
+                        else if (field === "age" && !neededCircuits.includes("compare_age")) {
+                            neededCircuits.push("compare_age");
+                        }
+                        break;
+                    case "gte":
+                    case "gt":
+                    case "lte":
+                    case "lt":
+                    case "range":
+                        if (field === "age" && !neededCircuits.includes("compare_age")) {
+                            neededCircuits.push("compare_age");
+                        }
+                        else if (field === "expiry_date" && !neededCircuits.includes("compare_expiry")) {
+                            neededCircuits.push("compare_expiry");
+                        }
+                        else if (field === "birthdate" && !neededCircuits.includes("compare_birthdate")) {
+                            neededCircuits.push("compare_birthdate");
+                        }
+                        break;
+                    case "in":
+                        if (field === "nationality" && !neededCircuits.includes("inclusion_check_country")) {
+                            neededCircuits.push("inclusion_check_country");
+                        }
+                        break;
+                    case "out":
+                        if (field === "nationality" && !neededCircuits.includes("exclusion_check_country")) {
+                            neededCircuits.push("exclusion_check_country");
+                        }
+                        break;
+                }
+            }
+        }
+        // From the circuits needed, determine the expected proof count
+        // There are at least 4 proofs, 3 base proofs and 1 disclosure proof minimum
+        // Each separate needed circuit adds 1 disclosure proof
+        this.topicToExpectedProofCount[topic] =
+            neededCircuits.length === 0 ? 4 : 3 + neededCircuits.length;
+    }
     /**
      * @notice Handle an encrypted message.
      * @param request The request.
@@ -92,7 +177,7 @@ class ZKPassport {
         else if (request.method === "proof") {
             logger_1.noLogger.debug(`User generated proof`);
             // Uncompress the proof and convert it to a hex string
-            const bytesProof = Buffer.from(request.params.proof, "base64");
+            const bytesProof = buffer_1.Buffer.from(request.params.proof, "base64");
             const uncompressedProof = await (0, node_gzip_1.ungzip)(bytesProof);
             // The gzip lib in the app compress the proof as ASCII
             // and since the app passes the proof as a hex string, we can
@@ -106,19 +191,44 @@ class ZKPassport {
             };
             this.topicToProofs[topic].push(processedProof);
             await Promise.all(this.onProofGeneratedCallbacks[topic].map((callback) => callback(processedProof)));
+            // If the results were received before all the proofs were generated,
+            // we can handle the result now
+            if (this.topicToResults[topic] &&
+                this.topicToExpectedProofCount[topic] === this.topicToProofs[topic].length) {
+                await this.handleResult(topic);
+            }
         }
         else if (request.method === "done") {
             logger_1.noLogger.debug(`User sent the query result`);
-            // Verify the proofs and extract the unique identifier (aka nullifier) and the verification result
-            const { uniqueIdentifier, verified } = await this.verify(topic, this.topicToProofs[topic], request.params);
-            await Promise.all(this.onResultCallbacks[topic].map((callback) => callback({
-                uniqueIdentifier,
-                verified,
-                result: request.params,
-            })));
+            this.topicToResults[topic] = request.params;
+            // Make sure all the proofs have been received, otherwise we'll handle the result later
+            // once the proofs have all been received
+            if (this.topicToExpectedProofCount[topic] === this.topicToProofs[topic].length) {
+                await this.handleResult(topic);
+            }
         }
         else if (request.method === "error") {
-            await Promise.all(this.onErrorCallbacks[topic].map((callback) => callback(request.params.error)));
+            const error = request.params.error;
+            if (error && error === "This ID is not supported yet") {
+                // This means the user has an ID that is not supported yet
+                // So we won't receive any proofs and we can handle the result now
+                this.topicToExpectedProofCount[topic] = 0;
+                if (this.topicToResults[topic]) {
+                    await this.handleResult(topic);
+                }
+            }
+            else if (error && error.startsWith("Cannot generate proof")) {
+                // This means one of the disclosure proofs failed to be generated
+                // So we need to remove one from the expected proof count
+                this.topicToExpectedProofCount[topic] -= 1;
+                // If the expected proof count is now equal to the number of proofs received
+                // and the results were received, we can handle the result now
+                if (this.topicToResults[topic] &&
+                    this.topicToExpectedProofCount[topic] === this.topicToProofs[topic].length) {
+                    await this.handleResult(topic);
+                }
+            }
+            await Promise.all(this.onErrorCallbacks[topic].map((callback) => callback(error)));
         }
     }
     getZkPassportRequest(topic) {
@@ -171,9 +281,10 @@ class ZKPassport {
               return this.getZkPassportRequest(topic)
             },*/
             done: () => {
-                const base64Config = Buffer.from(JSON.stringify(this.topicToConfig[topic])).toString("base64");
-                const base64Service = Buffer.from(JSON.stringify(this.topicToService[topic])).toString("base64");
+                const base64Config = buffer_1.Buffer.from(JSON.stringify(this.topicToConfig[topic])).toString("base64");
+                const base64Service = buffer_1.Buffer.from(JSON.stringify(this.topicToService[topic])).toString("base64");
                 const pubkey = (0, utils_2.bytesToHex)(this.topicToKeyPair[topic].publicKey);
+                this.setExpectedProofCount(topic);
                 return {
                     url: `https://zkpassport.id/r?d=${this.domain}&t=${topic}&c=${base64Config}&s=${base64Service}&p=${pubkey}`,
                     requestId: topic,
@@ -204,6 +315,7 @@ class ZKPassport {
         this.topicToConfig[topic] = {};
         this.topicToService[topic] = { name, logo, purpose, scope };
         this.topicToProofs[topic] = [];
+        this.topicToExpectedProofCount[topic] = 0;
         this.onRequestReceivedCallbacks[topic] = [];
         this.onGeneratingProofCallbacks[topic] = [];
         this.onBridgeConnectCallbacks[topic] = [];
@@ -226,7 +338,7 @@ class ZKPassport {
                     logger_1.noLogger.debug("[frontend] Received handshake:", event.data);
                     this.topicToRequestReceived[topic] = true;
                     this.topicToSharedSecret[topic] = await (0, encryption_1.getSharedSecret)((0, utils_2.bytesToHex)(keyPair.privateKey), data.params.pubkey);
-                    logger_1.noLogger.debug("[frontend] Shared secret:", Buffer.from(this.topicToSharedSecret[topic]).toString("hex"));
+                    logger_1.noLogger.debug("[frontend] Shared secret:", buffer_1.Buffer.from(this.topicToSharedSecret[topic]).toString("hex"));
                     const encryptedMessage = await (0, json_rpc_1.createEncryptedJsonRpcRequest)("hello", null, this.topicToSharedSecret[topic], topic);
                     logger_1.noLogger.debug("[frontend] Sending encrypted message:", encryptedMessage);
                     wsClient.send(JSON.stringify(encryptedMessage));
@@ -745,6 +857,16 @@ class ZKPassport {
                     isCorrect = false;
                     break;
                 }
+                // Check the countryList is in ascending order
+                // If the prover doesn't use a sorted list then the proof cannot be trusted
+                // as it is requirement in the circuit for the exclusion check to work
+                for (let i = 1; i < countryList.length; i++) {
+                    if (countryList[i] < countryList[i - 1]) {
+                        console.warn("The nationality exclusion list has not been sorted, and thus the proof cannot be trusted");
+                        isCorrect = false;
+                        break;
+                    }
+                }
                 uniqueIdentifier = (0, utils_1.getNullifierFromDisclosureProof)(proofData).toString(10);
             }
             else if (proof.name === "inclusion_check_country") {
@@ -789,7 +911,7 @@ class ZKPassport {
             proofsToVerify = this.topicToProofs[requestId];
             if (!proofsToVerify || proofsToVerify.length < 4) {
                 // It may happen that a request returns a result without proofs
-                // Meaning the ID is supported yet by ZKPassport circuits,
+                // Meaning the ID is not supported yet by ZKPassport circuits,
                 // so the results has to be trusted and cannot be independently verified
                 return { uniqueIdentifier: undefined, verified: false };
             }
@@ -811,7 +933,7 @@ class ZKPassport {
             for (const proof of proofsToVerify) {
                 const proofData = (0, utils_1.getProofData)(proof.proof, true);
                 const hostedPackagedCircuit = await (0, utils_1.getHostedPackagedCircuitByName)(proof.version, proof.name);
-                const vkeyBytes = Buffer.from(hostedPackagedCircuit.vkey, "base64");
+                const vkeyBytes = buffer_1.Buffer.from(hostedPackagedCircuit.vkey, "base64");
                 try {
                     verified = await verifier.verifyUltraHonkProof(proofData, new Uint8Array(vkeyBytes));
                 }
@@ -836,8 +958,8 @@ class ZKPassport {
      */
     getUrl(requestId) {
         const pubkey = (0, utils_2.bytesToHex)(this.topicToKeyPair[requestId].publicKey);
-        const base64Config = Buffer.from(JSON.stringify(this.topicToConfig[requestId])).toString("base64");
-        const base64Service = Buffer.from(JSON.stringify(this.topicToService[requestId])).toString("base64");
+        const base64Config = buffer_1.Buffer.from(JSON.stringify(this.topicToConfig[requestId])).toString("base64");
+        const base64Service = buffer_1.Buffer.from(JSON.stringify(this.topicToService[requestId])).toString("base64");
         return `https://zkpassport.id/r?d=${this.domain}&t=${requestId}&c=${base64Config}&s=${base64Service}&p=${pubkey}`;
     }
     /**
@@ -851,6 +973,8 @@ class ZKPassport {
         delete this.topicToConfig[requestId];
         delete this.topicToSharedSecret[requestId];
         delete this.topicToProofs[requestId];
+        delete this.topicToExpectedProofCount[requestId];
+        delete this.topicToResults[requestId];
         this.onRequestReceivedCallbacks[requestId] = [];
         this.onGeneratingProofCallbacks[requestId] = [];
         this.onBridgeConnectCallbacks[requestId] = [];

package/dist/esm/encryption.d.ts

@@ -1,7 +1,7 @@
 export declare function generateECDHKeyPair(): Promise<{
-    privateKey: Uint8Array;
-    publicKey: Uint8Array;
+    privateKey: import("@noble/secp256k1").Bytes;
+    publicKey: import("@noble/secp256k1").Bytes;
 }>;
-export declare function getSharedSecret(privateKey: string, publicKey: string): Promise<Uint8Array>;
-export declare function encrypt(message: string, sharedSecret: Uint8Array, topic: string): Promise<Uint8Array>;
+export declare function getSharedSecret(privateKey: string, publicKey: string): Promise<Uint8Array<ArrayBuffer>>;
+export declare function encrypt(message: string, sharedSecret: Uint8Array, topic: string): Promise<Uint8Array<ArrayBufferLike>>;
 export declare function decrypt(ciphertext: Uint8Array, sharedSecret: Uint8Array, topic: string): Promise<string>;

package/dist/esm/index.d.ts

@@ -134,6 +134,8 @@ export declare class ZKPassport {
     private topicToRequestReceived;
     private topicToService;
     private topicToProofs;
+    private topicToExpectedProofCount;
+    private topicToResults;
     private onRequestReceivedCallbacks;
     private onGeneratingProofCallbacks;
     private onBridgeConnectCallbacks;
@@ -142,6 +144,8 @@ export declare class ZKPassport {
     private onRejectCallbacks;
     private onErrorCallbacks;
     constructor(_domain?: string);
+    private handleResult;
+    private setExpectedProofCount;
     /**
      * @notice Handle an encrypted message.
      * @param request The request.

package/dist/esm/index.js

@@ -10,7 +10,26 @@ import { ungzip } from "node-gzip";
 //import initNoirC from '@noir-lang/noirc_abi'
 //import initACVM from '@noir-lang/acvm_js'
 import i18en from "i18n-iso-countries/langs/en.json";
+import { Buffer } from "buffer/";
+// If Buffer is not defined, then we use the Buffer from the buffer package
+if (typeof globalThis.Buffer === "undefined") {
+    globalThis.Buffer = Buffer;
+}
 registerLocale(i18en);
+function hasRequestedAccessToField(credentialsRequest, field) {
+    const fieldValue = credentialsRequest[field];
+    const isDefined = fieldValue !== undefined && fieldValue !== null;
+    if (!isDefined) {
+        return false;
+    }
+    for (const key in fieldValue) {
+        if (fieldValue[key] !== undefined &&
+            fieldValue[key] !== null) {
+            return true;
+        }
+    }
+    return false;
+}
 function normalizeCountry(country) {
     let normalizedCountry;
     const alpha3 = getAlpha3Code(country, "en");
@@ -46,6 +65,8 @@ export class ZKPassport {
         this.topicToRequestReceived = {};
         this.topicToService = {};
         this.topicToProofs = {};
+        this.topicToExpectedProofCount = {};
+        this.topicToResults = {};
         this.onRequestReceivedCallbacks = {};
         this.onGeneratingProofCallbacks = {};
         this.onBridgeConnectCallbacks = {};
@@ -64,6 +85,70 @@ export class ZKPassport {
       await Promise.all([initACVM(acvm), initNoirC(noirc)])
       this.wasmVerifierInit = true
     }*/
+    async handleResult(topic) {
+        const result = this.topicToResults[topic];
+        // Clear the results straight away to avoid concurrency issues
+        delete this.topicToResults[topic];
+        // Verify the proofs and extract the unique identifier (aka nullifier) and the verification result
+        const { uniqueIdentifier, verified } = await this.verify(topic, this.topicToProofs[topic], result);
+        await Promise.all(this.onResultCallbacks[topic].map((callback) => callback({
+            uniqueIdentifier,
+            verified,
+            result,
+        })));
+        // Clear the expected proof count
+        delete this.topicToExpectedProofCount[topic];
+    }
+    setExpectedProofCount(topic) {
+        const fields = Object.keys(this.topicToConfig[topic]).filter((key) => hasRequestedAccessToField(this.topicToConfig[topic], key));
+        const neededCircuits = [];
+        // Determine which circuits are needed based on the requested fields
+        for (const field of fields) {
+            for (const key in this.topicToConfig[topic][field]) {
+                switch (key) {
+                    case "eq":
+                    case "disclose":
+                        if (field !== "age" && !neededCircuits.includes("disclose_bytes")) {
+                            neededCircuits.push("disclose_bytes");
+                        }
+                        else if (field === "age" && !neededCircuits.includes("compare_age")) {
+                            neededCircuits.push("compare_age");
+                        }
+                        break;
+                    case "gte":
+                    case "gt":
+                    case "lte":
+                    case "lt":
+                    case "range":
+                        if (field === "age" && !neededCircuits.includes("compare_age")) {
+                            neededCircuits.push("compare_age");
+                        }
+                        else if (field === "expiry_date" && !neededCircuits.includes("compare_expiry")) {
+                            neededCircuits.push("compare_expiry");
+                        }
+                        else if (field === "birthdate" && !neededCircuits.includes("compare_birthdate")) {
+                            neededCircuits.push("compare_birthdate");
+                        }
+                        break;
+                    case "in":
+                        if (field === "nationality" && !neededCircuits.includes("inclusion_check_country")) {
+                            neededCircuits.push("inclusion_check_country");
+                        }
+                        break;
+                    case "out":
+                        if (field === "nationality" && !neededCircuits.includes("exclusion_check_country")) {
+                            neededCircuits.push("exclusion_check_country");
+                        }
+                        break;
+                }
+            }
+        }
+        // From the circuits needed, determine the expected proof count
+        // There are at least 4 proofs, 3 base proofs and 1 disclosure proof minimum
+        // Each separate needed circuit adds 1 disclosure proof
+        this.topicToExpectedProofCount[topic] =
+            neededCircuits.length === 0 ? 4 : 3 + neededCircuits.length;
+    }
     /**
      * @notice Handle an encrypted message.
      * @param request The request.
@@ -96,19 +181,44 @@ export class ZKPassport {
             };
             this.topicToProofs[topic].push(processedProof);
             await Promise.all(this.onProofGeneratedCallbacks[topic].map((callback) => callback(processedProof)));
+            // If the results were received before all the proofs were generated,
+            // we can handle the result now
+            if (this.topicToResults[topic] &&
+                this.topicToExpectedProofCount[topic] === this.topicToProofs[topic].length) {
+                await this.handleResult(topic);
+            }
         }
         else if (request.method === "done") {
             logger.debug(`User sent the query result`);
-            // Verify the proofs and extract the unique identifier (aka nullifier) and the verification result
-            const { uniqueIdentifier, verified } = await this.verify(topic, this.topicToProofs[topic], request.params);
-            await Promise.all(this.onResultCallbacks[topic].map((callback) => callback({
-                uniqueIdentifier,
-                verified,
-                result: request.params,
-            })));
+            this.topicToResults[topic] = request.params;
+            // Make sure all the proofs have been received, otherwise we'll handle the result later
+            // once the proofs have all been received
+            if (this.topicToExpectedProofCount[topic] === this.topicToProofs[topic].length) {
+                await this.handleResult(topic);
+            }
         }
         else if (request.method === "error") {
-            await Promise.all(this.onErrorCallbacks[topic].map((callback) => callback(request.params.error)));
+            const error = request.params.error;
+            if (error && error === "This ID is not supported yet") {
+                // This means the user has an ID that is not supported yet
+                // So we won't receive any proofs and we can handle the result now
+                this.topicToExpectedProofCount[topic] = 0;
+                if (this.topicToResults[topic]) {
+                    await this.handleResult(topic);
+                }
+            }
+            else if (error && error.startsWith("Cannot generate proof")) {
+                // This means one of the disclosure proofs failed to be generated
+                // So we need to remove one from the expected proof count
+                this.topicToExpectedProofCount[topic] -= 1;
+                // If the expected proof count is now equal to the number of proofs received
+                // and the results were received, we can handle the result now
+                if (this.topicToResults[topic] &&
+                    this.topicToExpectedProofCount[topic] === this.topicToProofs[topic].length) {
+                    await this.handleResult(topic);
+                }
+            }
+            await Promise.all(this.onErrorCallbacks[topic].map((callback) => callback(error)));
         }
     }
     getZkPassportRequest(topic) {
@@ -164,6 +274,7 @@ export class ZKPassport {
                 const base64Config = Buffer.from(JSON.stringify(this.topicToConfig[topic])).toString("base64");
                 const base64Service = Buffer.from(JSON.stringify(this.topicToService[topic])).toString("base64");
                 const pubkey = bytesToHex(this.topicToKeyPair[topic].publicKey);
+                this.setExpectedProofCount(topic);
                 return {
                     url: `https://zkpassport.id/r?d=${this.domain}&t=${topic}&c=${base64Config}&s=${base64Service}&p=${pubkey}`,
                     requestId: topic,
@@ -194,6 +305,7 @@ export class ZKPassport {
         this.topicToConfig[topic] = {};
         this.topicToService[topic] = { name, logo, purpose, scope };
         this.topicToProofs[topic] = [];
+        this.topicToExpectedProofCount[topic] = 0;
         this.onRequestReceivedCallbacks[topic] = [];
         this.onGeneratingProofCallbacks[topic] = [];
         this.onBridgeConnectCallbacks[topic] = [];
@@ -735,6 +847,16 @@ export class ZKPassport {
                     isCorrect = false;
                     break;
                 }
+                // Check the countryList is in ascending order
+                // If the prover doesn't use a sorted list then the proof cannot be trusted
+                // as it is requirement in the circuit for the exclusion check to work
+                for (let i = 1; i < countryList.length; i++) {
+                    if (countryList[i] < countryList[i - 1]) {
+                        console.warn("The nationality exclusion list has not been sorted, and thus the proof cannot be trusted");
+                        isCorrect = false;
+                        break;
+                    }
+                }
                 uniqueIdentifier = getNullifierFromDisclosureProof(proofData).toString(10);
             }
             else if (proof.name === "inclusion_check_country") {
@@ -779,7 +901,7 @@ export class ZKPassport {
             proofsToVerify = this.topicToProofs[requestId];
             if (!proofsToVerify || proofsToVerify.length < 4) {
                 // It may happen that a request returns a result without proofs
-                // Meaning the ID is supported yet by ZKPassport circuits,
+                // Meaning the ID is not supported yet by ZKPassport circuits,
                 // so the results has to be trusted and cannot be independently verified
                 return { uniqueIdentifier: undefined, verified: false };
             }
@@ -841,6 +963,8 @@ export class ZKPassport {
         delete this.topicToConfig[requestId];
         delete this.topicToSharedSecret[requestId];
         delete this.topicToProofs[requestId];
+        delete this.topicToExpectedProofCount[requestId];
+        delete this.topicToResults[requestId];
         this.onRequestReceivedCallbacks[requestId] = [];
         this.onGeneratingProofCallbacks[requestId] = [];
         this.onBridgeConnectCallbacks[requestId] = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zkpassport/sdk",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "Privacy-preserving identity verification using passports and ID cards",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
@@ -34,13 +34,15 @@
     "@types/node-gzip": "^1.1.3",
     "@types/ws": "^8.5.12",
     "jest": "^29.7.0",
+    "ts-node": "^10.9.2",
     "typescript": "^5.6.2"
   },
   "dependencies": {
     "@aztec/bb.js": "^0.67.0",
     "@noble/ciphers": "^1.2.1",
     "@noble/secp256k1": "^2.2.3",
-    "@zkpassport/utils": "^0.2.12",
+    "@zkpassport/utils": "^0.2.16",
+    "buffer": "^6.0.3",
     "i18n-iso-countries": "^7.12.0",
     "node-gzip": "^1.1.2",
     "ws": "^8.18.0"

package/src/index.ts

@@ -30,6 +30,7 @@ import {
   DisclosedData,
   formatName,
   getHostedPackagedCircuitByName,
+  Query,
 } from "@zkpassport/utils"
 import { bytesToHex } from "@noble/ciphers/utils"
 import { getWebSocketClient, WebSocketClient } from "./websocket"
@@ -40,9 +41,32 @@ import { ungzip } from "node-gzip"
 //import initNoirC from '@noir-lang/noirc_abi'
 //import initACVM from '@noir-lang/acvm_js'
 import i18en from "i18n-iso-countries/langs/en.json"
+import { Buffer } from "buffer/"
+
+// If Buffer is not defined, then we use the Buffer from the buffer package
+if (typeof globalThis.Buffer === "undefined") {
+  globalThis.Buffer = Buffer as any
+}
 
 registerLocale(i18en)
 
+function hasRequestedAccessToField(credentialsRequest: Query, field: IDCredential): boolean {
+  const fieldValue = credentialsRequest[field as keyof Query]
+  const isDefined = fieldValue !== undefined && fieldValue !== null
+  if (!isDefined) {
+    return false
+  }
+  for (const key in fieldValue) {
+    if (
+      fieldValue[key as keyof typeof fieldValue] !== undefined &&
+      fieldValue[key as keyof typeof fieldValue] !== null
+    ) {
+      return true
+    }
+  }
+  return false
+}
+
 function normalizeCountry(country: CountryName | Alpha3Code) {
   let normalizedCountry: Alpha3Code | undefined
   const alpha3 = getAlpha3Code(country, "en") as Alpha3Code | undefined
@@ -242,6 +266,8 @@ export class ZKPassport {
     { name: string; logo: string; purpose: string; scope?: string }
   > = {}
   private topicToProofs: Record<string, Array<ProofResult>> = {}
+  private topicToExpectedProofCount: Record<string, number> = {}
+  private topicToResults: Record<string, QueryResult> = {}
 
   private onRequestReceivedCallbacks: Record<string, Array<() => void>> = {}
   private onGeneratingProofCallbacks: Record<string, Array<(topic: string) => void>> = {}
@@ -275,6 +301,79 @@ export class ZKPassport {
     this.wasmVerifierInit = true
   }*/
 
+  private async handleResult(topic: string) {
+    const result = this.topicToResults[topic]
+    // Clear the results straight away to avoid concurrency issues
+    delete this.topicToResults[topic]
+    // Verify the proofs and extract the unique identifier (aka nullifier) and the verification result
+    const { uniqueIdentifier, verified } = await this.verify(
+      topic,
+      this.topicToProofs[topic],
+      result,
+    )
+    await Promise.all(
+      this.onResultCallbacks[topic].map((callback) =>
+        callback({
+          uniqueIdentifier,
+          verified,
+          result,
+        }),
+      ),
+    )
+    // Clear the expected proof count
+    delete this.topicToExpectedProofCount[topic]
+  }
+
+  private setExpectedProofCount(topic: string) {
+    const fields = Object.keys(this.topicToConfig[topic] as Query).filter((key) =>
+      hasRequestedAccessToField(this.topicToConfig[topic] as Query, key as IDCredential),
+    )
+    const neededCircuits: string[] = []
+    // Determine which circuits are needed based on the requested fields
+    for (const field of fields) {
+      for (const key in this.topicToConfig[topic][field as IDCredential]) {
+        switch (key) {
+          case "eq":
+          case "disclose":
+            if (field !== "age" && !neededCircuits.includes("disclose_bytes")) {
+              neededCircuits.push("disclose_bytes")
+            } else if (field === "age" && !neededCircuits.includes("compare_age")) {
+              neededCircuits.push("compare_age")
+            }
+            break
+          case "gte":
+          case "gt":
+          case "lte":
+          case "lt":
+          case "range":
+            if (field === "age" && !neededCircuits.includes("compare_age")) {
+              neededCircuits.push("compare_age")
+            } else if (field === "expiry_date" && !neededCircuits.includes("compare_expiry")) {
+              neededCircuits.push("compare_expiry")
+            } else if (field === "birthdate" && !neededCircuits.includes("compare_birthdate")) {
+              neededCircuits.push("compare_birthdate")
+            }
+            break
+          case "in":
+            if (field === "nationality" && !neededCircuits.includes("inclusion_check_country")) {
+              neededCircuits.push("inclusion_check_country")
+            }
+            break
+          case "out":
+            if (field === "nationality" && !neededCircuits.includes("exclusion_check_country")) {
+              neededCircuits.push("exclusion_check_country")
+            }
+            break
+        }
+      }
+    }
+    // From the circuits needed, determine the expected proof count
+    // There are at least 4 proofs, 3 base proofs and 1 disclosure proof minimum
+    // Each separate needed circuit adds 1 disclosure proof
+    this.topicToExpectedProofCount[topic] =
+      neededCircuits.length === 0 ? 4 : 3 + neededCircuits.length
+  }
+
   /**
    * @notice Handle an encrypted message.
    * @param request The request.
@@ -311,27 +410,45 @@ export class ZKPassport {
       await Promise.all(
         this.onProofGeneratedCallbacks[topic].map((callback) => callback(processedProof)),
       )
+      // If the results were received before all the proofs were generated,
+      // we can handle the result now
+      if (
+        this.topicToResults[topic] &&
+        this.topicToExpectedProofCount[topic] === this.topicToProofs[topic].length
+      ) {
+        await this.handleResult(topic)
+      }
     } else if (request.method === "done") {
       logger.debug(`User sent the query result`)
-      // Verify the proofs and extract the unique identifier (aka nullifier) and the verification result
-      const { uniqueIdentifier, verified } = await this.verify(
-        topic,
-        this.topicToProofs[topic],
-        request.params,
-      )
-      await Promise.all(
-        this.onResultCallbacks[topic].map((callback) =>
-          callback({
-            uniqueIdentifier,
-            verified,
-            result: request.params,
-          }),
-        ),
-      )
+      this.topicToResults[topic] = request.params
+      // Make sure all the proofs have been received, otherwise we'll handle the result later
+      // once the proofs have all been received
+      if (this.topicToExpectedProofCount[topic] === this.topicToProofs[topic].length) {
+        await this.handleResult(topic)
+      }
     } else if (request.method === "error") {
-      await Promise.all(
-        this.onErrorCallbacks[topic].map((callback) => callback(request.params.error)),
-      )
+      const error = request.params.error
+      if (error && error === "This ID is not supported yet") {
+        // This means the user has an ID that is not supported yet
+        // So we won't receive any proofs and we can handle the result now
+        this.topicToExpectedProofCount[topic] = 0
+        if (this.topicToResults[topic]) {
+          await this.handleResult(topic)
+        }
+      } else if (error && error.startsWith("Cannot generate proof")) {
+        // This means one of the disclosure proofs failed to be generated
+        // So we need to remove one from the expected proof count
+        this.topicToExpectedProofCount[topic] -= 1
+        // If the expected proof count is now equal to the number of proofs received
+        // and the results were received, we can handle the result now
+        if (
+          this.topicToResults[topic] &&
+          this.topicToExpectedProofCount[topic] === this.topicToProofs[topic].length
+        ) {
+          await this.handleResult(topic)
+        }
+      }
+      await Promise.all(this.onErrorCallbacks[topic].map((callback) => callback(error)))
     }
   }
 
@@ -396,6 +513,7 @@ export class ZKPassport {
           "base64",
         )
         const pubkey = bytesToHex(this.topicToKeyPair[topic].publicKey)
+        this.setExpectedProofCount(topic)
         return {
           url: `https://zkpassport.id/r?d=${this.domain}&t=${topic}&c=${base64Config}&s=${base64Service}&p=${pubkey}`,
           requestId: topic,
@@ -442,7 +560,7 @@ export class ZKPassport {
     scope?: string
     topicOverride?: string
     keyPairOverride?: { privateKey: Uint8Array; publicKey: Uint8Array }
-  }) {
+  }): Promise<QueryBuilder> {
     const topic = topicOverride || randomBytes(16).toString("hex")
 
     const keyPair = keyPairOverride || (await generateECDHKeyPair())
@@ -454,6 +572,7 @@ export class ZKPassport {
     this.topicToConfig[topic] = {}
     this.topicToService[topic] = { name, logo, purpose, scope }
     this.topicToProofs[topic] = []
+    this.topicToExpectedProofCount[topic] = 0
 
     this.onRequestReceivedCallbacks[topic] = []
     this.onGeneratingProofCallbacks[topic] = []
@@ -1108,6 +1227,18 @@ export class ZKPassport {
           isCorrect = false
           break
         }
+        // Check the countryList is in ascending order
+        // If the prover doesn't use a sorted list then the proof cannot be trusted
+        // as it is requirement in the circuit for the exclusion check to work
+        for (let i = 1; i < countryList.length; i++) {
+          if (countryList[i] < countryList[i - 1]) {
+            console.warn(
+              "The nationality exclusion list has not been sorted, and thus the proof cannot be trusted",
+            )
+            isCorrect = false
+            break
+          }
+        }
         uniqueIdentifier = getNullifierFromDisclosureProof(proofData).toString(10)
       } else if (proof.name === "inclusion_check_country") {
         commitmentIn = getCommitmentInFromDisclosureProof(proofData)
@@ -1161,7 +1292,7 @@ export class ZKPassport {
       proofsToVerify = this.topicToProofs[requestId]
       if (!proofsToVerify || proofsToVerify.length < 4) {
         // It may happen that a request returns a result without proofs
-        // Meaning the ID is supported yet by ZKPassport circuits,
+        // Meaning the ID is not supported yet by ZKPassport circuits,
         // so the results has to be trusted and cannot be independently verified
         return { uniqueIdentifier: undefined, verified: false }
       }
@@ -1232,6 +1363,8 @@ export class ZKPassport {
     delete this.topicToConfig[requestId]
     delete this.topicToSharedSecret[requestId]
     delete this.topicToProofs[requestId]
+    delete this.topicToExpectedProofCount[requestId]
+    delete this.topicToResults[requestId]
     this.onRequestReceivedCallbacks[requestId] = []
     this.onGeneratingProofCallbacks[requestId] = []
     this.onBridgeConnectCallbacks[requestId] = []

package/tsconfig.json

@@ -12,8 +12,7 @@
     "rootDir": "./src",
     "baseUrl": ".",
     "paths": {
-      "@/*": ["./src/*"],
-      "@/types": ["src/types/index.ts"]
+      "@/*": ["./src/*"]
     },
     "declaration": true,
     "isolatedModules": true,