@zkpassport/sdk 0.2.7 → 0.2.9

package/dist/esm/index.js

@@ -62,6 +62,7 @@ export class ZKPassport {
     //private wasmVerifierInit: boolean = false
     constructor(_domain) {
         this.topicToConfig = {};
+        this.topicToLocalConfig = {};
         this.topicToKeyPair = {};
         this.topicToWebSocketClient = {};
         this.topicToSharedSecret = {};
@@ -69,6 +70,7 @@ export class ZKPassport {
         this.topicToService = {};
         this.topicToProofs = {};
         this.topicToExpectedProofCount = {};
+        this.topicToFailedProofCount = {};
         this.topicToResults = {};
         this.onRequestReceivedCallbacks = {};
         this.onGeneratingProofCallbacks = {};
@@ -93,14 +95,19 @@ export class ZKPassport {
         // 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);
+        const { uniqueIdentifier, verified, queryResultErrors } = await this.verify(topic, this.topicToProofs[topic], result);
+        const hasFailedProofs = this.topicToFailedProofCount[topic] > 0;
         await Promise.all(this.onResultCallbacks[topic].map((callback) => callback({
-            uniqueIdentifier,
-            verified,
+            // If there are failed proofs, we don't return the unique identifier
+            // and we set the verified result to false
+            uniqueIdentifier: hasFailedProofs ? undefined : uniqueIdentifier,
+            verified: hasFailedProofs ? false : verified,
             result,
+            queryResultErrors,
         })));
-        // Clear the expected proof count
+        // Clear the expected proof count and failed proof count
         delete this.topicToExpectedProofCount[topic];
+        delete this.topicToFailedProofCount[topic];
     }
     setExpectedProofCount(topic) {
         const fields = Object.keys(this.topicToConfig[topic]).filter((key) => hasRequestedAccessToField(this.topicToConfig[topic], key));
@@ -151,6 +158,7 @@ export class ZKPassport {
         // Each separate needed circuit adds 1 disclosure proof
         this.topicToExpectedProofCount[topic] =
             neededCircuits.length === 0 ? 4 : 3 + neededCircuits.length;
+        this.topicToFailedProofCount[topic] = 0;
     }
     /**
      * @notice Handle an encrypted message.
@@ -206,6 +214,7 @@ export class ZKPassport {
                 // 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;
+                this.topicToFailedProofCount[topic] += this.topicToExpectedProofCount[topic];
                 if (this.topicToResults[topic]) {
                     await this.handleResult(topic);
                 }
@@ -214,6 +223,7 @@ export class ZKPassport {
                 // 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;
+                this.topicToFailedProofCount[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] &&
@@ -270,9 +280,6 @@ export class ZKPassport {
                 };
                 return this.getZkPassportRequest(topic);
             },
-            /*checkAML: (country?: CountryName | Alpha2Code | Alpha3Code) => {
-              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");
@@ -295,10 +302,15 @@ export class ZKPassport {
         };
     }
     /**
-     * @notice Create a new request.
+     * @notice Create a new request
+     * @param name Your service name
+     * @param logo The logo of your service
+     * @param purpose To explain what you want to do with the user's data
+     * @param scope Scope this request to a specific use case
+     * @param validity How many days ago should have the ID been last scanned by the user?
      * @returns The query builder object.
      */
-    async request({ name, logo, purpose, scope, topicOverride, keyPairOverride, }) {
+    async request({ name, logo, purpose, scope, validity, topicOverride, keyPairOverride, }) {
         const topic = topicOverride || randomBytes(16).toString("hex");
         const keyPair = keyPairOverride || (await generateECDHKeyPair());
         this.topicToKeyPair[topic] = {
@@ -309,6 +321,10 @@ export class ZKPassport {
         this.topicToService[topic] = { name, logo, purpose, scope };
         this.topicToProofs[topic] = [];
         this.topicToExpectedProofCount[topic] = 0;
+        this.topicToLocalConfig[topic] = {
+            // Default to 6 months
+            validity: validity || 6 * 30,
+        };
         this.onRequestReceivedCallbacks[topic] = [];
         this.onGeneratingProofCallbacks[topic] = [];
         this.onBridgeConnectCallbacks[topic] = [];
@@ -365,7 +381,7 @@ export class ZKPassport {
         };
         return this.getZkPassportRequest(topic);
     }
-    async checkPublicInputs(proofs, queryResult) {
+    async checkPublicInputs(proofs, queryResult, topic) {
         let commitmentIn;
         let commitmentOut;
         let isCorrect = true;
@@ -374,6 +390,23 @@ export class ZKPassport {
         const defaultDateValue = new Date(1111, 10, 11);
         const currentTime = new Date();
         const today = new Date(currentTime.getFullYear(), currentTime.getMonth(), currentTime.getDate(), 0, 0, 0, 0);
+        const queryResultErrors = {
+            sig_check_dsc: {},
+            sig_check_id_data: {},
+            data_check_integrity: {},
+            disclose: {},
+            age: {},
+            birthdate: {},
+            expiry_date: {},
+            document_type: {},
+            issuing_country: {},
+            gender: {},
+            nationality: {},
+            firstname: {},
+            lastname: {},
+            fullname: {},
+            document_number: {},
+        };
         // Since the order is important for the commitments, we need to sort the proofs
         // by their expected order: root signature check -> ID signature check -> integrity check -> disclosure
         const sortedProofs = proofs.sort((a, b) => {
@@ -402,7 +435,11 @@ export class ZKPassport {
                 if (merkleRoot !== expectedMerkleRoot) {
                     console.warn("The ID was signed by an unrecognized root certificate");
                     isCorrect = false;
-                    break;
+                    queryResultErrors.sig_check_dsc.certificate = {
+                        expected: `Certificate registry root: ${expectedMerkleRoot.toString()}`,
+                        received: `Certificate registry root: ${merkleRoot.toString()}`,
+                        message: "The ID was signed by an unrecognized root certificate",
+                    };
                 }
             }
             else if (proof.name?.startsWith("sig_check_id_data")) {
@@ -410,7 +447,11 @@ export class ZKPassport {
                 if (commitmentIn !== commitmentOut) {
                     console.warn("Failed to check the link between the certificate signature and ID signature");
                     isCorrect = false;
-                    break;
+                    queryResultErrors.sig_check_id_data.commitment = {
+                        expected: `Commitment: ${commitmentOut?.toString() || "undefined"}`,
+                        received: `Commitment: ${commitmentIn?.toString() || "undefined"}`,
+                        message: "Failed to check the link between the certificate signature and ID signature",
+                    };
                 }
                 commitmentOut = getCommitmentOutFromIDDataProof(proofData);
             }
@@ -419,17 +460,26 @@ export class ZKPassport {
                 if (commitmentIn !== commitmentOut) {
                     console.warn("Failed to check the link between the ID signature and the data signed");
                     isCorrect = false;
-                    break;
+                    queryResultErrors.data_check_integrity.commitment = {
+                        expected: `Commitment: ${commitmentOut?.toString() || "undefined"}`,
+                        received: `Commitment: ${commitmentIn?.toString() || "undefined"}`,
+                        message: "Failed to check the link between the ID signature and the data signed",
+                    };
                 }
                 commitmentOut = getCommitmentOutFromIntegrityProof(proofData);
                 const currentDate = getCurrentDateFromIntegrityProof(proofData);
-                // The date should be today or yesterday
-                // (if the proof request was requested just before midnight and is finalized after)
-                if (currentDate.getTime() !== today.getTime() &&
-                    currentDate.getTime() !== today.getTime() - 86400000) {
-                    console.warn("Current date used to check the validity of the ID is too old");
+                const todayToCurrentDate = today.getTime() - currentDate.getTime();
+                const expectedDifference = this.topicToLocalConfig[topic]?.validity * 86400000;
+                const actualDifference = today.getTime() - (today.getTime() - expectedDifference);
+                // The ID should not expire within the next 6 months (or whatever the custom value is)
+                if (todayToCurrentDate >= actualDifference) {
+                    console.warn(`The date used to check the validity of the ID is older than ${this.topicToLocalConfig[topic]?.validity} days. You can ask the user to rescan their ID or ask them to disclose their expiry date`);
                     isCorrect = false;
-                    break;
+                    queryResultErrors.data_check_integrity.date = {
+                        expected: `Difference: ${this.topicToLocalConfig[topic]?.validity} days`,
+                        received: `Difference: ${Math.round(todayToCurrentDate / 86400000)} days`,
+                        message: "The date used to check the validity of the ID is older than the validity period",
+                    };
                 }
             }
             else if (proof.name === "disclose_bytes") {
@@ -437,7 +487,11 @@ export class ZKPassport {
                 if (commitmentIn !== commitmentOut) {
                     console.warn("Failed to check the link between the validity of the ID and the data to disclose");
                     isCorrect = false;
-                    break;
+                    queryResultErrors.disclose.commitment = {
+                        expected: `Commitment: ${commitmentOut?.toString() || "undefined"}`,
+                        received: `Commitment: ${commitmentIn?.toString() || "undefined"}`,
+                        message: "Failed to check the link between the validity of the ID and the data to disclose",
+                    };
                 }
                 // We can't be certain that the disclosed data is for a passport or an ID card
                 // so we need to check both (unless the document type is revealed)
@@ -450,12 +504,20 @@ export class ZKPassport {
                         queryResult.document_type.eq.expected !== disclosedDataPassport.documentType) {
                         console.warn("Document type does not match the expected document type");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.document_type.eq = {
+                            expected: `${queryResult.document_type.eq.expected}`,
+                            received: `${disclosedDataPassport.documentType}`,
+                            message: "Document type does not match the expected document type",
+                        };
                     }
                     if (queryResult.document_type.disclose?.result !== disclosedDataIDCard.documentType) {
                         console.warn("Document type does not match the disclosed document type in query result");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.document_type.disclose = {
+                            expected: `${queryResult.document_type.disclose?.result}`,
+                            received: `${disclosedDataIDCard.documentType}`,
+                            message: "Document type does not match the disclosed document type in query result",
+                        };
                     }
                 }
                 if (queryResult.birthdate) {
@@ -467,14 +529,22 @@ export class ZKPassport {
                         queryResult.birthdate.eq.expected.getTime() !== birthdateIDCard.getTime()) {
                         console.warn("Birthdate does not match the expected birthdate");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.birthdate.eq = {
+                            expected: `${queryResult.birthdate.eq.expected.toISOString()}`,
+                            received: `${birthdatePassport.toISOString()}`,
+                            message: "Birthdate does not match the expected birthdate",
+                        };
                     }
                     if (queryResult.birthdate.disclose &&
                         queryResult.birthdate.disclose.result.getTime() !== birthdatePassport.getTime() &&
                         queryResult.birthdate.disclose.result.getTime() !== birthdateIDCard.getTime()) {
                         console.warn("Birthdate does not match the disclosed birthdate in query result");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.birthdate.disclose = {
+                            expected: `${queryResult.birthdate.disclose.result.toISOString()}`,
+                            received: `${birthdatePassport.toISOString()}`,
+                            message: "Birthdate does not match the disclosed birthdate in query result",
+                        };
                     }
                 }
                 if (queryResult.expiry_date) {
@@ -486,14 +556,22 @@ export class ZKPassport {
                         queryResult.expiry_date.eq.expected.getTime() !== expiryDateIDCard.getTime()) {
                         console.warn("Expiry date does not match the expected expiry date");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.expiry_date.eq = {
+                            expected: `${queryResult.expiry_date.eq.expected.toISOString()}`,
+                            received: `${expiryDatePassport.toISOString()}`,
+                            message: "Expiry date does not match the expected expiry date",
+                        };
                     }
                     if (queryResult.expiry_date.disclose &&
                         queryResult.expiry_date.disclose.result.getTime() !== expiryDatePassport.getTime() &&
                         queryResult.expiry_date.disclose.result.getTime() !== expiryDateIDCard.getTime()) {
                         console.warn("Expiry date does not match the disclosed expiry date in query result");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.expiry_date.disclose = {
+                            expected: `${queryResult.expiry_date.disclose.result.toISOString()}`,
+                            received: `${expiryDatePassport.toISOString()}`,
+                            message: "Expiry date does not match the disclosed expiry date in query result",
+                        };
                     }
                 }
                 if (queryResult.nationality) {
@@ -505,14 +583,22 @@ export class ZKPassport {
                         queryResult.nationality.eq.expected !== nationalityIDCard) {
                         console.warn("Nationality does not match the expected nationality");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.nationality.eq = {
+                            expected: `${queryResult.nationality.eq.expected}`,
+                            received: `${nationalityPassport}`,
+                            message: "Nationality does not match the expected nationality",
+                        };
                     }
                     if (queryResult.nationality.disclose &&
                         queryResult.nationality.disclose.result !== nationalityPassport &&
                         queryResult.nationality.disclose.result !== nationalityIDCard) {
                         console.warn("Nationality does not match the disclosed nationality in query result");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.nationality.disclose = {
+                            expected: `${queryResult.nationality.disclose.result}`,
+                            received: `${nationalityPassport}`,
+                            message: "Nationality does not match the disclosed nationality in query result",
+                        };
                     }
                 }
                 if (queryResult.document_number) {
@@ -524,14 +610,22 @@ export class ZKPassport {
                         queryResult.document_number.eq.expected !== documentNumberIDCard) {
                         console.warn("Document number does not match the expected document number");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.document_number.eq = {
+                            expected: `${queryResult.document_number.eq.expected}`,
+                            received: `${documentNumberPassport}`,
+                            message: "Document number does not match the expected document number",
+                        };
                     }
                     if (queryResult.document_number.disclose &&
                         queryResult.document_number.disclose.result !== documentNumberPassport &&
                         queryResult.document_number.disclose.result !== documentNumberIDCard) {
                         console.warn("Document number does not match the disclosed document number in query result");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.document_number.disclose = {
+                            expected: `${queryResult.document_number.disclose.result}`,
+                            received: `${documentNumberPassport}`,
+                            message: "Document number does not match the disclosed document number in query result",
+                        };
                     }
                 }
                 if (queryResult.gender) {
@@ -543,14 +637,22 @@ export class ZKPassport {
                         queryResult.gender.eq.expected !== genderIDCard) {
                         console.warn("Gender does not match the expected gender");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.gender.eq = {
+                            expected: `${queryResult.gender.eq.expected}`,
+                            received: `${genderPassport}`,
+                            message: "Gender does not match the expected gender",
+                        };
                     }
                     if (queryResult.gender.disclose &&
                         queryResult.gender.disclose.result !== genderPassport &&
                         queryResult.gender.disclose.result !== genderIDCard) {
                         console.warn("Gender does not match the disclosed gender in query result");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.gender.disclose = {
+                            expected: `${queryResult.gender.disclose.result}`,
+                            received: `${genderPassport}`,
+                            message: "Gender does not match the disclosed gender in query result",
+                        };
                     }
                 }
                 if (queryResult.issuing_country) {
@@ -562,14 +664,22 @@ export class ZKPassport {
                         queryResult.issuing_country.eq.expected !== issuingCountryIDCard) {
                         console.warn("Issuing country does not match the expected issuing country");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.issuing_country.eq = {
+                            expected: `${queryResult.issuing_country.eq.expected}`,
+                            received: `${issuingCountryPassport}`,
+                            message: "Issuing country does not match the expected issuing country",
+                        };
                     }
                     if (queryResult.issuing_country.disclose &&
                         queryResult.issuing_country.disclose.result !== issuingCountryPassport &&
                         queryResult.issuing_country.disclose.result !== issuingCountryIDCard) {
                         console.warn("Issuing country does not match the disclosed issuing country in query result");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.issuing_country.disclose = {
+                            expected: `${queryResult.issuing_country.disclose.result}`,
+                            received: `${issuingCountryPassport}`,
+                            message: "Issuing country does not match the disclosed issuing country in query result",
+                        };
                     }
                 }
                 if (queryResult.fullname) {
@@ -583,7 +693,11 @@ export class ZKPassport {
                             fullnameIDCard.toLowerCase()) {
                         console.warn("Fullname does not match the expected fullname");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.fullname.eq = {
+                            expected: `${queryResult.fullname.eq.expected}`,
+                            received: `${fullnamePassport}`,
+                            message: "Fullname does not match the expected fullname",
+                        };
                     }
                     if (queryResult.fullname.disclose &&
                         formatName(queryResult.fullname.disclose.result).toLowerCase() !==
@@ -592,7 +706,11 @@ export class ZKPassport {
                             fullnameIDCard.toLowerCase()) {
                         console.warn("Fullname does not match the disclosed fullname in query result");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.fullname.disclose = {
+                            expected: `${queryResult.fullname.disclose.result}`,
+                            received: `${fullnamePassport}`,
+                            message: "Fullname does not match the disclosed fullname in query result",
+                        };
                     }
                 }
                 if (queryResult.firstname) {
@@ -611,7 +729,11 @@ export class ZKPassport {
                             firstnameIDCard.toLowerCase()) {
                         console.warn("Firstname does not match the expected firstname");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.firstname.eq = {
+                            expected: `${queryResult.firstname.eq.expected}`,
+                            received: `${firstnamePassport}`,
+                            message: "Firstname does not match the expected firstname",
+                        };
                     }
                     if (queryResult.firstname.disclose &&
                         formatName(queryResult.firstname.disclose.result).toLowerCase() !==
@@ -620,7 +742,11 @@ export class ZKPassport {
                             firstnameIDCard.toLowerCase()) {
                         console.warn("Firstname does not match the disclosed firstname in query result");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.firstname.disclose = {
+                            expected: `${queryResult.firstname.disclose.result}`,
+                            received: `${firstnamePassport}`,
+                            message: "Firstname does not match the disclosed firstname in query result",
+                        };
                     }
                 }
                 if (queryResult.lastname) {
@@ -639,7 +765,11 @@ export class ZKPassport {
                             lastnameIDCard.toLowerCase()) {
                         console.warn("Lastname does not match the expected lastname");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.lastname.eq = {
+                            expected: `${queryResult.lastname.eq.expected}`,
+                            received: `${lastnamePassport}`,
+                            message: "Lastname does not match the expected lastname",
+                        };
                     }
                     if (queryResult.lastname.disclose &&
                         formatName(queryResult.lastname.disclose.result).toLowerCase() !==
@@ -648,7 +778,11 @@ export class ZKPassport {
                             lastnameIDCard.toLowerCase()) {
                         console.warn("Lastname does not match the disclosed lastname in query result");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.lastname.disclose = {
+                            expected: `${queryResult.lastname.disclose.result}`,
+                            received: `${lastnamePassport}`,
+                            message: "Lastname does not match the disclosed lastname in query result",
+                        };
                     }
                 }
                 uniqueIdentifier = getNullifierFromDisclosureProof(proofData).toString(10);
@@ -658,7 +792,11 @@ export class ZKPassport {
                 if (commitmentIn !== commitmentOut) {
                     console.warn("Failed to check the link between the validity of the ID and the age derived from it");
                     isCorrect = false;
-                    break;
+                    queryResultErrors.age.commitment = {
+                        expected: `Commitment: ${commitmentOut}`,
+                        received: `Commitment: ${commitmentIn}`,
+                        message: "Failed to check the link between the validity of the ID and the age derived from it",
+                    };
                 }
                 const minAge = getMinAgeFromProof(proofData);
                 const maxAge = getMaxAgeFromProof(proofData);
@@ -668,14 +806,22 @@ export class ZKPassport {
                         minAge < queryResult.age.gte.expected) {
                         console.warn("Age is not greater than or equal to the expected age");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.age.gte = {
+                            expected: queryResult.age.gte.expected,
+                            received: minAge,
+                            message: "Age is not greater than or equal to the expected age",
+                        };
                     }
                     if (queryResult.age.lt &&
                         queryResult.age.lt.result &&
                         maxAge >= queryResult.age.lt.expected) {
                         console.warn("Age is not less than the expected age");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.age.lt = {
+                            expected: queryResult.age.lt.expected,
+                            received: maxAge,
+                            message: "Age is not less than the expected age",
+                        };
                     }
                     if (queryResult.age.range) {
                         if (queryResult.age.range.result &&
@@ -683,38 +829,60 @@ export class ZKPassport {
                                 maxAge >= queryResult.age.range.expected[1])) {
                             console.warn("Age is not in the expected range");
                             isCorrect = false;
-                            break;
+                            queryResultErrors.age.range = {
+                                expected: queryResult.age.range.expected,
+                                received: [minAge, maxAge],
+                                message: "Age is not in the expected range",
+                            };
                         }
                     }
                     if (!queryResult.age.lt && !queryResult.age.range && maxAge != 0) {
                         console.warn("Maximum age should be equal to 0");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.age.disclose = {
+                            expected: 0,
+                            received: maxAge,
+                            message: "Maximum age should be equal to 0",
+                        };
                     }
                     if (!queryResult.age.gte && !queryResult.age.range && minAge != 0) {
                         console.warn("Minimum age should be equal to 0");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.age.disclose = {
+                            expected: 0,
+                            received: minAge,
+                            message: "Minimum age should be equal to 0",
+                        };
                     }
                     if (queryResult.age.disclose &&
                         (queryResult.age.disclose.result !== minAge ||
                             queryResult.age.disclose.result !== maxAge)) {
                         console.warn("Age does not match the disclosed age in query result");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.age.disclose = {
+                            expected: `${minAge}`,
+                            received: `${queryResult.age.disclose.result}`,
+                            message: "Age does not match the disclosed age in query result",
+                        };
                     }
                 }
                 else {
                     console.warn("Age is not set in the query result");
                     isCorrect = false;
-                    break;
+                    queryResultErrors.age.disclose = {
+                        message: "Age is not set in the query result",
+                    };
                 }
                 const currentDate = getCurrentDateFromAgeProof(proofData);
                 if (currentDate.getTime() !== today.getTime() &&
                     currentDate.getTime() !== today.getTime() - 86400000) {
                     console.warn("Current date in the proof is too old");
                     isCorrect = false;
-                    break;
+                    queryResultErrors.age.disclose = {
+                        expected: `${today.toISOString()}`,
+                        received: `${currentDate.toISOString()}`,
+                        message: "Current date in the proof is too old",
+                    };
                 }
                 uniqueIdentifier = getCommitmentInFromDisclosureProof(proofData).toString(10);
             }
@@ -723,7 +891,11 @@ export class ZKPassport {
                 if (commitmentIn !== commitmentOut) {
                     console.warn("Failed to check the link between the validity of the ID and the birthdate derived from it");
                     isCorrect = false;
-                    break;
+                    queryResultErrors.birthdate.commitment = {
+                        expected: `Commitment: ${commitmentOut}`,
+                        received: `Commitment: ${commitmentIn}`,
+                        message: "Failed to check the link between the validity of the ID and the birthdate derived from it",
+                    };
                 }
                 const minDate = getMinDateFromProof(proofData);
                 const maxDate = getMaxDateFromProof(proofData);
@@ -733,14 +905,22 @@ export class ZKPassport {
                         minDate < queryResult.birthdate.gte.expected) {
                         console.warn("Birthdate is not greater than or equal to the expected birthdate");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.birthdate.gte = {
+                            expected: queryResult.birthdate.gte.expected,
+                            received: minDate,
+                            message: "Birthdate is not greater than or equal to the expected birthdate",
+                        };
                     }
                     if (queryResult.birthdate.lte &&
                         queryResult.birthdate.lte.result &&
                         maxDate > queryResult.birthdate.lte.expected) {
                         console.warn("Birthdate is not less than the expected birthdate");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.birthdate.lte = {
+                            expected: queryResult.birthdate.lte.expected,
+                            received: maxDate,
+                            message: "Birthdate is not less than the expected birthdate",
+                        };
                     }
                     if (queryResult.birthdate.range) {
                         if (queryResult.birthdate.range.result &&
@@ -748,7 +928,11 @@ export class ZKPassport {
                                 maxDate > queryResult.birthdate.range.expected[1])) {
                             console.warn("Birthdate is not in the expected range");
                             isCorrect = false;
-                            break;
+                            queryResultErrors.birthdate.range = {
+                                expected: queryResult.birthdate.range.expected,
+                                received: [minDate, maxDate],
+                                message: "Birthdate is not in the expected range",
+                            };
                         }
                     }
                     if (!queryResult.birthdate.lte &&
@@ -756,20 +940,30 @@ export class ZKPassport {
                         maxDate.getTime() != defaultDateValue.getTime()) {
                         console.warn("Maximum birthdate should be equal to default date value");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.birthdate.disclose = {
+                            expected: `${defaultDateValue.toISOString()}`,
+                            received: `${maxDate.toISOString()}`,
+                            message: "Maximum birthdate should be equal to default date value",
+                        };
                     }
                     if (!queryResult.birthdate.gte &&
                         !queryResult.birthdate.range &&
                         minDate.getTime() != defaultDateValue.getTime()) {
                         console.warn("Minimum birthdate should be equal to default date value");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.birthdate.disclose = {
+                            expected: `${defaultDateValue.toISOString()}`,
+                            received: `${minDate.toISOString()}`,
+                            message: "Minimum birthdate should be equal to default date value",
+                        };
                     }
                 }
                 else {
                     console.warn("Birthdate is not set in the query result");
                     isCorrect = false;
-                    break;
+                    queryResultErrors.birthdate.disclose = {
+                        message: "Birthdate is not set in the query result",
+                    };
                 }
                 uniqueIdentifier = getCommitmentInFromDisclosureProof(proofData).toString(10);
             }
@@ -778,7 +972,11 @@ export class ZKPassport {
                 if (commitmentIn !== commitmentOut) {
                     console.warn("Failed to check the link between the validity of the ID and its expiry date");
                     isCorrect = false;
-                    break;
+                    queryResultErrors.expiry_date.commitment = {
+                        expected: `Commitment: ${commitmentOut}`,
+                        received: `Commitment: ${commitmentIn}`,
+                        message: "Failed to check the link between the validity of the ID and its expiry date",
+                    };
                 }
                 const minDate = getMinDateFromProof(proofData);
                 const maxDate = getMaxDateFromProof(proofData);
@@ -788,14 +986,22 @@ export class ZKPassport {
                         minDate < queryResult.expiry_date.gte.expected) {
                         console.warn("Expiry date is not greater than or equal to the expected expiry date");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.expiry_date.gte = {
+                            expected: queryResult.expiry_date.gte.expected,
+                            received: minDate,
+                            message: "Expiry date is not greater than or equal to the expected expiry date",
+                        };
                     }
                     if (queryResult.expiry_date.lte &&
                         queryResult.expiry_date.lte.result &&
                         maxDate > queryResult.expiry_date.lte.expected) {
                         console.warn("Expiry date is not less than the expected expiry date");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.expiry_date.lte = {
+                            expected: queryResult.expiry_date.lte.expected,
+                            received: maxDate,
+                            message: "Expiry date is not less than the expected expiry date",
+                        };
                     }
                     if (queryResult.expiry_date.range) {
                         if (queryResult.expiry_date.range.result &&
@@ -803,7 +1009,11 @@ export class ZKPassport {
                                 maxDate > queryResult.expiry_date.range.expected[1])) {
                             console.warn("Expiry date is not in the expected range");
                             isCorrect = false;
-                            break;
+                            queryResultErrors.expiry_date.range = {
+                                expected: queryResult.expiry_date.range.expected,
+                                received: [minDate, maxDate],
+                                message: "Expiry date is not in the expected range",
+                            };
                         }
                     }
                     if (!queryResult.expiry_date.lte &&
@@ -811,20 +1021,30 @@ export class ZKPassport {
                         maxDate.getTime() != defaultDateValue.getTime()) {
                         console.warn("Maximum expiry date should be equal to default date value");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.expiry_date.disclose = {
+                            expected: `${defaultDateValue.toISOString()}`,
+                            received: `${maxDate.toISOString()}`,
+                            message: "Maximum expiry date should be equal to default date value",
+                        };
                     }
                     if (!queryResult.expiry_date.gte &&
                         !queryResult.expiry_date.range &&
                         minDate.getTime() != defaultDateValue.getTime()) {
                         console.warn("Minimum expiry date should be equal to default date value");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.expiry_date.disclose = {
+                            expected: `${defaultDateValue.toISOString()}`,
+                            received: `${minDate.toISOString()}`,
+                            message: "Minimum expiry date should be equal to default date value",
+                        };
                     }
                 }
                 else {
                     console.warn("Expiry date is not set in the query result");
                     isCorrect = false;
-                    break;
+                    queryResultErrors.expiry_date.disclose = {
+                        message: "Expiry date is not set in the query result",
+                    };
                 }
                 uniqueIdentifier = getNullifierFromDisclosureProof(proofData).toString(10);
             }
@@ -833,7 +1053,11 @@ export class ZKPassport {
                 if (commitmentIn !== commitmentOut) {
                     console.warn("Failed to check the link between the validity of the ID and the country exclusion check");
                     isCorrect = false;
-                    break;
+                    queryResultErrors.nationality.commitment = {
+                        expected: `Commitment: ${commitmentOut}`,
+                        received: `Commitment: ${commitmentIn}`,
+                        message: "Failed to check the link between the validity of the ID and the country exclusion check",
+                    };
                 }
                 const countryList = getCountryListFromExclusionProof(proofData);
                 if (queryResult.nationality &&
@@ -842,13 +1066,19 @@ export class ZKPassport {
                     if (!queryResult.nationality.out.expected?.every((country) => countryList.includes(country))) {
                         console.warn("Country exclusion list does not match the one from the query results");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.nationality.out = {
+                            expected: queryResult.nationality.out.expected,
+                            received: countryList,
+                            message: "Country exclusion list does not match the one from the query results",
+                        };
                     }
                 }
                 else if (!queryResult.nationality || !queryResult.nationality.out) {
                     console.warn("Nationality exclusion is not set in the query result");
                     isCorrect = false;
-                    break;
+                    queryResultErrors.nationality.out = {
+                        message: "Nationality exclusion is not set in the query result",
+                    };
                 }
                 // Check the countryList is in ascending order
                 // If the prover doesn't use a sorted list then the proof cannot be trusted
@@ -857,7 +1087,9 @@ export class ZKPassport {
                     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;
+                        queryResultErrors.nationality.out = {
+                            message: "The nationality exclusion list has not been sorted, and thus the proof cannot be trusted",
+                        };
                     }
                 }
                 uniqueIdentifier = getNullifierFromDisclosureProof(proofData).toString(10);
@@ -867,7 +1099,11 @@ export class ZKPassport {
                 if (commitmentIn !== commitmentOut) {
                     console.warn("Failed to check the link between the validity of the ID and the country inclusion check");
                     isCorrect = false;
-                    break;
+                    queryResultErrors.nationality.commitment = {
+                        expected: `Commitment: ${commitmentOut}`,
+                        received: `Commitment: ${commitmentIn}`,
+                        message: "Failed to check the link between the validity of the ID and the country inclusion check",
+                    };
                 }
                 const countryList = getCountryListFromInclusionProof(proofData);
                 if (queryResult.nationality &&
@@ -876,18 +1112,24 @@ export class ZKPassport {
                     if (!queryResult.nationality.in.expected?.every((country) => countryList.includes(country))) {
                         console.warn("Country inclusion list does not match the one from the query results");
                         isCorrect = false;
-                        break;
+                        queryResultErrors.nationality.in = {
+                            expected: queryResult.nationality.in.expected,
+                            received: countryList,
+                            message: "Country inclusion list does not match the one from the query results",
+                        };
                     }
                 }
                 else if (!queryResult.nationality || !queryResult.nationality.in) {
                     console.warn("Nationality inclusion is not set in the query result");
                     isCorrect = false;
-                    break;
+                    queryResultErrors.nationality.in = {
+                        message: "Nationality inclusion is not set in the query result",
+                    };
                 }
                 uniqueIdentifier = getNullifierFromDisclosureProof(proofData).toString(10);
             }
         }
-        return { isCorrect, uniqueIdentifier };
+        return { isCorrect, uniqueIdentifier, queryResultErrors };
     }
     /**
      * @notice Verify the proofs received from the mobile app.
@@ -902,12 +1144,6 @@ export class ZKPassport {
         // There is a minimum of 4 subproofs to make a complete proof
         if (!proofs || proofs.length < 4) {
             proofsToVerify = this.topicToProofs[requestId];
-            if (!proofsToVerify || proofsToVerify.length < 4) {
-                // It may happen that a request returns a result without proofs
-                // 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 };
-            }
         }
         const { BarretenbergVerifier } = await import("@aztec/bb.js");
         const verifier = new BarretenbergVerifier();
@@ -916,13 +1152,15 @@ export class ZKPassport {
         }*/
         let verified = true;
         let uniqueIdentifier;
+        let queryResultErrors;
         if (queryResult) {
-            const { isCorrect, uniqueIdentifier: uniqueIdentifierFromPublicInputs } = await this.checkPublicInputs(proofsToVerify, queryResult);
+            const { isCorrect, uniqueIdentifier: uniqueIdentifierFromPublicInputs, queryResultErrors: queryResultErrorsFromPublicInputs, } = await this.checkPublicInputs(proofsToVerify, queryResult, requestId);
             uniqueIdentifier = uniqueIdentifierFromPublicInputs;
             verified = isCorrect;
+            queryResultErrors = isCorrect ? undefined : queryResultErrorsFromPublicInputs;
         }
         // Only proceed with the proof verification if the public inputs are correct
-        if (verified) {
+        if (verified && queryResult) {
             for (const proof of proofsToVerify) {
                 const proofData = getProofData(proof.proof, true);
                 const hostedPackagedCircuit = await getHostedPackagedCircuitByName(proof.version, proof.name);
@@ -942,7 +1180,7 @@ export class ZKPassport {
             }
         }
         this.topicToProofs[requestId] = [];
-        return { uniqueIdentifier, verified };
+        return { uniqueIdentifier, verified, queryResultErrors };
     }
     /**
      * @notice Returns the URL of the request.
@@ -960,13 +1198,17 @@ export class ZKPassport {
      * @param requestId The request ID.
      */
     cancelRequest(requestId) {
-        this.topicToWebSocketClient[requestId].close();
-        delete this.topicToWebSocketClient[requestId];
+        if (this.topicToWebSocketClient[requestId]) {
+            this.topicToWebSocketClient[requestId].close();
+            delete this.topicToWebSocketClient[requestId];
+        }
         delete this.topicToKeyPair[requestId];
         delete this.topicToConfig[requestId];
+        delete this.topicToLocalConfig[requestId];
         delete this.topicToSharedSecret[requestId];
         delete this.topicToProofs[requestId];
         delete this.topicToExpectedProofCount[requestId];
+        delete this.topicToFailedProofCount[requestId];
         delete this.topicToResults[requestId];
         this.onRequestReceivedCallbacks[requestId] = [];
         this.onGeneratingProofCallbacks[requestId] = [];
@@ -975,4 +1217,12 @@ export class ZKPassport {
         this.onRejectCallbacks[requestId] = [];
         this.onErrorCallbacks[requestId] = [];
     }
+    /**
+     * @notice Clears all requests.
+     */
+    clearAllRequests() {
+        for (const requestId in this.topicToWebSocketClient) {
+            this.cancelRequest(requestId);
+        }
+    }
 }