@zkpassport/sdk 0.8.0-beta.1 → 0.8.0-beta.2

package/dist/cjs/index.cjs

@@ -815,6 +815,7 @@ var import_bridge = require("@obsidion/bridge");
 var import_utils4 = require("@zkpassport/utils");
 var VERSION = "0.8.0";
 var DEFAULT_DATE_VALUE = /* @__PURE__ */ new Date(0);
+var DEFAULT_VALIDITY = 7 * 24 * 60 * 60;
 if (typeof globalThis.Buffer === "undefined") {
   globalThis.Buffer = import_buffer.Buffer;
   if (typeof window !== "undefined") {
@@ -863,7 +864,6 @@ function generalCompare(fnName, key, value, requestId, requestIdToConfig) {
   };
 }
 var ZKPassport = class {
-  //private wasmVerifierInit: boolean = false
   constructor(_domain) {
     this.topicToConfig = {};
     this.topicToLocalConfig = {};
@@ -885,7 +885,11 @@ var ZKPassport = class {
     if (!_domain && typeof window === "undefined") {
       throw new Error("Domain argument is required in Node.js environment");
     }
-    this.domain = _domain || window.location.hostname;
+    this.domain = this.normalizeDomain(_domain || window.location.hostname);
+  }
+  //private wasmVerifierInit: boolean = false
+  normalizeDomain(domain) {
+    return domain.trim().replace(/^https?:\/\//, "").replace(/^.*\.([a-zA-Z0-9\-]+\.[a-zA-Z0-9\-]+)/, "$1").replace(/\/[^/]*$/, "").replace(/:[0-9]+/, "").replace(/\?.*$/, "").replace(/#.*$/, "").toLowerCase();
   }
   async handleResult(topic) {
     const result = this.topicToResults[topic];
@@ -968,7 +972,7 @@ var ZKPassport = class {
       neededCircuits.push("bind");
     }
     if (this.topicToConfig[topic].sanctions) {
-      neededCircuits.push("sanctions");
+      neededCircuits.push("exclusion_check_sanctions");
     }
     if (this.topicToConfig[topic].facematch) {
       neededCircuits.push("facematch");
@@ -1092,12 +1096,13 @@ var ZKPassport = class {
         };
         return this.getZkPassportRequest(topic);
       },
-      facematch: (mode = "strict") => {
+      // TODO: Uncomment this when the facematch is ready
+      /*facematch: (mode: FacematchMode = "regular") => {
         this.topicToConfig[topic].facematch = {
-          mode
-        };
-        return this.getZkPassportRequest(topic);
-      },
+          mode,
+        }
+        return this.getZkPassportRequest(topic)
+      },*/
       done: () => {
         this.setExpectedProofCount(topic);
         return {
@@ -1122,7 +1127,7 @@ var ZKPassport = class {
    * @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?
+   * @param validity How many seconds ago the proof checking the expiry date of the ID should have been generated
    * @param devMode Whether to enable dev mode. This will allow you to verify mock proofs (i.e. from ZKR)
    * @returns The query builder object.
    */
@@ -1157,8 +1162,8 @@ var ZKPassport = class {
     this.topicToProofs[topic] = [];
     this.topicToExpectedProofCount[topic] = 0;
     this.topicToLocalConfig[topic] = {
-      // Default to 6 months
-      validity: validity || 6 * 30,
+      // Default to 7 days
+      validity: validity || DEFAULT_VALIDITY,
       mode: mode || "fast",
       devMode: devMode || false
     };
@@ -1187,25 +1192,7 @@ var ZKPassport = class {
     return this.getZkPassportRequest(topic);
   }
   checkDiscloseBytesPublicInputs(proof, queryResult) {
-    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: {},
-      outer: {},
-      bind: {}
-    };
+    const queryResultErrors = {};
     let isCorrect = true;
     const disclosedDataPassport = import_utils.DisclosedData.fromDisclosedBytes(
       (proof.committedInputs?.disclose_bytes).disclosedBytes,
@@ -1219,19 +1206,25 @@ var ZKPassport = class {
       if (queryResult.document_type.eq && queryResult.document_type.eq.result && queryResult.document_type.eq.expected !== disclosedDataPassport.documentType) {
         console.warn("Document type does not match the expected document type");
         isCorrect = false;
-        queryResultErrors.document_type.eq = {
-          expected: `${queryResult.document_type.eq.expected}`,
-          received: `${disclosedDataPassport.documentType ?? disclosedDataIDCard.documentType}`,
-          message: "Document type does not match the expected document type"
+        queryResultErrors.document_type = {
+          ...queryResultErrors.document_type,
+          eq: {
+            expected: `${queryResult.document_type.eq.expected}`,
+            received: `${disclosedDataPassport.documentType ?? disclosedDataIDCard.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;
-        queryResultErrors.document_type.disclose = {
-          expected: `${queryResult.document_type.disclose?.result}`,
-          received: `${disclosedDataIDCard.documentType ?? disclosedDataPassport.documentType}`,
-          message: "Document type does not match the disclosed document type in query result"
+        queryResultErrors.document_type = {
+          ...queryResultErrors.document_type,
+          disclose: {
+            expected: `${queryResult.document_type.disclose?.result}`,
+            received: `${disclosedDataIDCard.documentType ?? disclosedDataPassport.documentType}`,
+            message: "Document type does not match the disclosed document type in query result"
+          }
         };
       }
     }
@@ -1241,19 +1234,25 @@ var ZKPassport = class {
       if (queryResult.birthdate.eq && queryResult.birthdate.eq.result && !(0, import_utils.areDatesEqual)(queryResult.birthdate.eq.expected, birthdatePassport) && !(0, import_utils.areDatesEqual)(queryResult.birthdate.eq.expected, birthdateIDCard)) {
         console.warn("Birthdate does not match the expected birthdate");
         isCorrect = false;
-        queryResultErrors.birthdate.eq = {
-          expected: `${queryResult.birthdate.eq.expected.toISOString()}`,
-          received: `${birthdatePassport?.toISOString() ?? birthdateIDCard?.toISOString()}`,
-          message: "Birthdate does not match the expected birthdate"
+        queryResultErrors.birthdate = {
+          ...queryResultErrors.birthdate,
+          eq: {
+            expected: `${queryResult.birthdate.eq.expected.toISOString()}`,
+            received: `${birthdatePassport?.toISOString() ?? birthdateIDCard?.toISOString()}`,
+            message: "Birthdate does not match the expected birthdate"
+          }
         };
       }
       if (queryResult.birthdate.disclose && !(0, import_utils.areDatesEqual)(queryResult.birthdate.disclose.result, birthdatePassport) && !(0, import_utils.areDatesEqual)(queryResult.birthdate.disclose.result, birthdateIDCard)) {
         console.warn("Birthdate does not match the disclosed birthdate in query result");
         isCorrect = false;
-        queryResultErrors.birthdate.disclose = {
-          expected: `${queryResult.birthdate.disclose.result.toISOString()}`,
-          received: `${birthdatePassport?.toISOString() ?? birthdateIDCard?.toISOString()}`,
-          message: "Birthdate does not match the disclosed birthdate in query result"
+        queryResultErrors.birthdate = {
+          ...queryResultErrors.birthdate,
+          disclose: {
+            expected: `${queryResult.birthdate.disclose.result.toISOString()}`,
+            received: `${birthdatePassport?.toISOString() ?? birthdateIDCard?.toISOString()}`,
+            message: "Birthdate does not match the disclosed birthdate in query result"
+          }
         };
       }
     }
@@ -1263,19 +1262,25 @@ var ZKPassport = class {
       if (queryResult.expiry_date.eq && queryResult.expiry_date.eq.result && !(0, import_utils.areDatesEqual)(queryResult.expiry_date.eq.expected, expiryDatePassport) && !(0, import_utils.areDatesEqual)(queryResult.expiry_date.eq.expected, expiryDateIDCard)) {
         console.warn("Expiry date does not match the expected expiry date");
         isCorrect = false;
-        queryResultErrors.expiry_date.eq = {
-          expected: `${queryResult.expiry_date.eq.expected.toISOString()}`,
-          received: `${expiryDatePassport?.toISOString() ?? expiryDateIDCard?.toISOString()}`,
-          message: "Expiry date does not match the expected expiry date"
+        queryResultErrors.expiry_date = {
+          ...queryResultErrors.expiry_date,
+          eq: {
+            expected: `${queryResult.expiry_date.eq.expected.toISOString()}`,
+            received: `${expiryDatePassport?.toISOString() ?? expiryDateIDCard?.toISOString()}`,
+            message: "Expiry date does not match the expected expiry date"
+          }
         };
       }
       if (queryResult.expiry_date.disclose && !(0, import_utils.areDatesEqual)(queryResult.expiry_date.disclose.result, expiryDatePassport) && !(0, import_utils.areDatesEqual)(queryResult.expiry_date.disclose.result, expiryDateIDCard)) {
         console.warn("Expiry date does not match the disclosed expiry date in query result");
         isCorrect = false;
-        queryResultErrors.expiry_date.disclose = {
-          expected: `${queryResult.expiry_date.disclose.result.toISOString()}`,
-          received: `${expiryDatePassport?.toISOString() ?? expiryDateIDCard?.toISOString()}`,
-          message: "Expiry date does not match the disclosed expiry date in query result"
+        queryResultErrors.expiry_date = {
+          ...queryResultErrors.expiry_date,
+          disclose: {
+            expected: `${queryResult.expiry_date.disclose.result.toISOString()}`,
+            received: `${expiryDatePassport?.toISOString() ?? expiryDateIDCard?.toISOString()}`,
+            message: "Expiry date does not match the disclosed expiry date in query result"
+          }
         };
       }
     }
@@ -1285,19 +1290,25 @@ var ZKPassport = class {
       if (queryResult.nationality.eq && queryResult.nationality.eq.result && queryResult.nationality.eq.expected !== nationalityPassport && queryResult.nationality.eq.expected !== nationalityIDCard) {
         console.warn("Nationality does not match the expected nationality");
         isCorrect = false;
-        queryResultErrors.nationality.eq = {
-          expected: `${queryResult.nationality.eq.expected}`,
-          received: `${nationalityPassport ?? nationalityIDCard}`,
-          message: "Nationality does not match the expected nationality"
+        queryResultErrors.nationality = {
+          ...queryResultErrors.nationality,
+          eq: {
+            expected: `${queryResult.nationality.eq.expected}`,
+            received: `${nationalityPassport ?? nationalityIDCard}`,
+            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;
-        queryResultErrors.nationality.disclose = {
-          expected: `${queryResult.nationality.disclose.result}`,
-          received: `${nationalityPassport ?? nationalityIDCard}`,
-          message: "Nationality does not match the disclosed nationality in query result"
+        queryResultErrors.nationality = {
+          ...queryResultErrors.nationality,
+          disclose: {
+            expected: `${queryResult.nationality.disclose.result}`,
+            received: `${nationalityPassport ?? nationalityIDCard}`,
+            message: "Nationality does not match the disclosed nationality in query result"
+          }
         };
       }
     }
@@ -1307,19 +1318,25 @@ var ZKPassport = class {
       if (queryResult.document_number.eq && queryResult.document_number.eq.result && queryResult.document_number.eq.expected !== documentNumberPassport && queryResult.document_number.eq.expected !== documentNumberIDCard) {
         console.warn("Document number does not match the expected document number");
         isCorrect = false;
-        queryResultErrors.document_number.eq = {
-          expected: `${queryResult.document_number.eq.expected}`,
-          received: `${documentNumberPassport ?? documentNumberIDCard}`,
-          message: "Document number does not match the expected document number"
+        queryResultErrors.document_number = {
+          ...queryResultErrors.document_number,
+          eq: {
+            expected: `${queryResult.document_number.eq.expected}`,
+            received: `${documentNumberPassport ?? documentNumberIDCard}`,
+            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;
-        queryResultErrors.document_number.disclose = {
-          expected: `${queryResult.document_number.disclose.result}`,
-          received: `${documentNumberPassport ?? documentNumberIDCard}`,
-          message: "Document number does not match the disclosed document number in query result"
+        queryResultErrors.document_number = {
+          ...queryResultErrors.document_number,
+          disclose: {
+            expected: `${queryResult.document_number.disclose.result}`,
+            received: `${documentNumberPassport ?? documentNumberIDCard}`,
+            message: "Document number does not match the disclosed document number in query result"
+          }
         };
       }
     }
@@ -1329,19 +1346,25 @@ var ZKPassport = class {
       if (queryResult.gender.eq && queryResult.gender.eq.result && queryResult.gender.eq.expected !== genderPassport && queryResult.gender.eq.expected !== genderIDCard) {
         console.warn("Gender does not match the expected gender");
         isCorrect = false;
-        queryResultErrors.gender.eq = {
-          expected: `${queryResult.gender.eq.expected}`,
-          received: `${genderPassport ?? genderIDCard}`,
-          message: "Gender does not match the expected gender"
+        queryResultErrors.gender = {
+          ...queryResultErrors.gender,
+          eq: {
+            expected: `${queryResult.gender.eq.expected}`,
+            received: `${genderPassport ?? genderIDCard}`,
+            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;
-        queryResultErrors.gender.disclose = {
-          expected: `${queryResult.gender.disclose.result}`,
-          received: `${genderPassport ?? genderIDCard}`,
-          message: "Gender does not match the disclosed gender in query result"
+        queryResultErrors.gender = {
+          ...queryResultErrors.gender,
+          disclose: {
+            expected: `${queryResult.gender.disclose.result}`,
+            received: `${genderPassport ?? genderIDCard}`,
+            message: "Gender does not match the disclosed gender in query result"
+          }
         };
       }
     }
@@ -1351,19 +1374,25 @@ var ZKPassport = class {
       if (queryResult.issuing_country.eq && queryResult.issuing_country.eq.result && queryResult.issuing_country.eq.expected !== issuingCountryPassport && queryResult.issuing_country.eq.expected !== issuingCountryIDCard) {
         console.warn("Issuing country does not match the expected issuing country");
         isCorrect = false;
-        queryResultErrors.issuing_country.eq = {
-          expected: `${queryResult.issuing_country.eq.expected}`,
-          received: `${issuingCountryPassport ?? issuingCountryIDCard}`,
-          message: "Issuing country does not match the expected issuing country"
+        queryResultErrors.issuing_country = {
+          ...queryResultErrors.issuing_country,
+          eq: {
+            expected: `${queryResult.issuing_country.eq.expected}`,
+            received: `${issuingCountryPassport ?? issuingCountryIDCard}`,
+            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;
-        queryResultErrors.issuing_country.disclose = {
-          expected: `${queryResult.issuing_country.disclose.result}`,
-          received: `${issuingCountryPassport ?? issuingCountryIDCard}`,
-          message: "Issuing country does not match the disclosed issuing country in query result"
+        queryResultErrors.issuing_country = {
+          ...queryResultErrors.issuing_country,
+          disclose: {
+            expected: `${queryResult.issuing_country.disclose.result}`,
+            received: `${issuingCountryPassport ?? issuingCountryIDCard}`,
+            message: "Issuing country does not match the disclosed issuing country in query result"
+          }
         };
       }
     }
@@ -1373,19 +1402,25 @@ var ZKPassport = class {
       if (queryResult.fullname.eq && queryResult.fullname.eq.result && (0, import_utils.formatName)(queryResult.fullname.eq.expected).toLowerCase() !== fullnamePassport.toLowerCase() && (0, import_utils.formatName)(queryResult.fullname.eq.expected).toLowerCase() !== fullnameIDCard.toLowerCase()) {
         console.warn("Fullname does not match the expected fullname");
         isCorrect = false;
-        queryResultErrors.fullname.eq = {
-          expected: `${queryResult.fullname.eq.expected}`,
-          received: `${fullnamePassport ?? fullnameIDCard}`,
-          message: "Fullname does not match the expected fullname"
+        queryResultErrors.fullname = {
+          ...queryResultErrors.fullname,
+          eq: {
+            expected: `${queryResult.fullname.eq.expected}`,
+            received: `${fullnamePassport ?? fullnameIDCard}`,
+            message: "Fullname does not match the expected fullname"
+          }
         };
       }
       if (queryResult.fullname.disclose && (0, import_utils.formatName)(queryResult.fullname.disclose.result).toLowerCase() !== fullnamePassport.toLowerCase() && (0, import_utils.formatName)(queryResult.fullname.disclose.result).toLowerCase() !== fullnameIDCard.toLowerCase()) {
         console.warn("Fullname does not match the disclosed fullname in query result");
         isCorrect = false;
-        queryResultErrors.fullname.disclose = {
-          expected: `${queryResult.fullname.disclose.result}`,
-          received: `${fullnamePassport ?? fullnameIDCard}`,
-          message: "Fullname does not match the disclosed fullname in query result"
+        queryResultErrors.fullname = {
+          ...queryResultErrors.fullname,
+          disclose: {
+            expected: `${queryResult.fullname.disclose.result}`,
+            received: `${fullnamePassport ?? fullnameIDCard}`,
+            message: "Fullname does not match the disclosed fullname in query result"
+          }
         };
       }
     }
@@ -1395,19 +1430,25 @@ var ZKPassport = class {
       if (queryResult.firstname.eq && queryResult.firstname.eq.result && (0, import_utils.formatName)(queryResult.firstname.eq.expected).toLowerCase() !== firstnamePassport.toLowerCase() && (0, import_utils.formatName)(queryResult.firstname.eq.expected).toLowerCase() !== firstnameIDCard.toLowerCase()) {
         console.warn("Firstname does not match the expected firstname");
         isCorrect = false;
-        queryResultErrors.firstname.eq = {
-          expected: `${queryResult.firstname.eq.expected}`,
-          received: `${firstnamePassport ?? firstnameIDCard}`,
-          message: "Firstname does not match the expected firstname"
+        queryResultErrors.firstname = {
+          ...queryResultErrors.firstname,
+          eq: {
+            expected: `${queryResult.firstname.eq.expected}`,
+            received: `${firstnamePassport ?? firstnameIDCard}`,
+            message: "Firstname does not match the expected firstname"
+          }
         };
       }
       if (queryResult.firstname.disclose && (0, import_utils.formatName)(queryResult.firstname.disclose.result).toLowerCase() !== firstnamePassport.toLowerCase() && (0, import_utils.formatName)(queryResult.firstname.disclose.result).toLowerCase() !== firstnameIDCard.toLowerCase()) {
         console.warn("Firstname does not match the disclosed firstname in query result");
         isCorrect = false;
-        queryResultErrors.firstname.disclose = {
-          expected: `${queryResult.firstname.disclose.result}`,
-          received: `${firstnamePassport ?? firstnameIDCard}`,
-          message: "Firstname does not match the disclosed firstname in query result"
+        queryResultErrors.firstname = {
+          ...queryResultErrors.firstname,
+          disclose: {
+            expected: `${queryResult.firstname.disclose.result}`,
+            received: `${firstnamePassport ?? firstnameIDCard}`,
+            message: "Firstname does not match the disclosed firstname in query result"
+          }
         };
       }
     }
@@ -1417,44 +1458,32 @@ var ZKPassport = class {
       if (queryResult.lastname.eq && queryResult.lastname.eq.result && (0, import_utils.formatName)(queryResult.lastname.eq.expected).toLowerCase() !== lastnamePassport.toLowerCase() && (0, import_utils.formatName)(queryResult.lastname.eq.expected).toLowerCase() !== lastnameIDCard.toLowerCase()) {
         console.warn("Lastname does not match the expected lastname");
         isCorrect = false;
-        queryResultErrors.lastname.eq = {
-          expected: `${queryResult.lastname.eq.expected}`,
-          received: `${lastnamePassport ?? lastnameIDCard}`,
-          message: "Lastname does not match the expected lastname"
+        queryResultErrors.lastname = {
+          ...queryResultErrors.lastname,
+          eq: {
+            expected: `${queryResult.lastname.eq.expected}`,
+            received: `${lastnamePassport ?? lastnameIDCard}`,
+            message: "Lastname does not match the expected lastname"
+          }
         };
       }
       if (queryResult.lastname.disclose && (0, import_utils.formatName)(queryResult.lastname.disclose.result).toLowerCase() !== lastnamePassport.toLowerCase() && (0, import_utils.formatName)(queryResult.lastname.disclose.result).toLowerCase() !== lastnameIDCard.toLowerCase()) {
         console.warn("Lastname does not match the disclosed lastname in query result");
         isCorrect = false;
-        queryResultErrors.lastname.disclose = {
-          expected: `${queryResult.lastname.disclose.result}`,
-          received: `${lastnamePassport ?? lastnameIDCard}`,
-          message: "Lastname does not match the disclosed lastname in query result"
+        queryResultErrors.lastname = {
+          ...queryResultErrors.lastname,
+          disclose: {
+            expected: `${queryResult.lastname.disclose.result}`,
+            received: `${lastnamePassport ?? lastnameIDCard}`,
+            message: "Lastname does not match the disclosed lastname in query result"
+          }
         };
       }
     }
     return { isCorrect, queryResultErrors };
   }
   checkAgePublicInputs(proof, queryResult) {
-    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: {},
-      outer: {},
-      bind: {}
-    };
+    const queryResultErrors = {};
     let isCorrect = true;
     const currentTime = /* @__PURE__ */ new Date();
     const today = new Date(
@@ -1476,64 +1505,85 @@ var ZKPassport = class {
       if (queryResult.age.gte && queryResult.age.gte.result && minAge !== queryResult.age.gte.expected) {
         console.warn("Age is not greater than or equal to the expected age");
         isCorrect = false;
-        queryResultErrors.age.gte = {
-          expected: queryResult.age.gte.expected,
-          received: minAge,
-          message: "Age is not greater than or equal to the expected age"
+        queryResultErrors.age = {
+          ...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;
-        queryResultErrors.age.lt = {
-          expected: queryResult.age.lt.expected,
-          received: maxAge,
-          message: "Age is not less than the expected age"
+        queryResultErrors.age = {
+          ...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 && (minAge !== queryResult.age.range.expected[0] || maxAge !== queryResult.age.range.expected[1])) {
           console.warn("Age is not in the expected range");
           isCorrect = false;
-          queryResultErrors.age.range = {
-            expected: queryResult.age.range.expected,
-            received: [minAge, maxAge],
-            message: "Age is not in the expected range"
+          queryResultErrors.age = {
+            ...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;
-        queryResultErrors.age.disclose = {
-          expected: 0,
-          received: maxAge,
-          message: "Maximum age should be equal to 0"
+        queryResultErrors.age = {
+          ...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;
-        queryResultErrors.age.disclose = {
-          expected: 0,
-          received: minAge,
-          message: "Minimum age should be equal to 0"
+        queryResultErrors.age = {
+          ...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;
-        queryResultErrors.age.disclose = {
-          expected: `${minAge}`,
-          received: `${queryResult.age.disclose.result}`,
-          message: "Age does not match the disclosed age in query result"
+        queryResultErrors.age = {
+          ...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;
-      queryResultErrors.age.disclose = {
-        message: "Age is not set in the query result"
+      queryResultErrors.age = {
+        ...queryResultErrors.age,
+        disclose: {
+          message: "Age is not set in the query result"
+        }
       };
     }
     const currentDate = (0, import_utils.getCurrentDateFromCommittedInputs)(
@@ -1542,34 +1592,19 @@ var ZKPassport = class {
     if (!(0, import_utils.areDatesEqual)(currentDate, today) && !(0, import_utils.areDatesEqual)(currentDate, today.getTime() - 864e5)) {
       console.warn("Current date in the proof is too old");
       isCorrect = false;
-      queryResultErrors.age.disclose = {
-        expected: `${today.toISOString()}`,
-        received: `${currentDate.toISOString()}`,
-        message: "Current date in the proof is too old"
+      queryResultErrors.age = {
+        ...queryResultErrors.age,
+        disclose: {
+          expected: `${today.toISOString()}`,
+          received: `${currentDate.toISOString()}`,
+          message: "Current date in the proof is too old"
+        }
       };
     }
     return { isCorrect, queryResultErrors };
   }
   checkBirthdatePublicInputs(proof, queryResult) {
-    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: {},
-      outer: {},
-      bind: {}
-    };
+    const queryResultErrors = {};
     let isCorrect = true;
     const currentTime = /* @__PURE__ */ new Date();
     const today = new Date(
@@ -1580,10 +1615,10 @@ var ZKPassport = class {
       0,
       0
     );
-    const minDate = (0, import_utils.getMinDateFromCommittedInputs)(
+    const minDate = (0, import_utils.getBirthdateMinDateTimestamp)(
       proof.committedInputs?.compare_birthdate
     );
-    const maxDate = (0, import_utils.getMaxDateFromCommittedInputs)(
+    const maxDate = (0, import_utils.getBirthdateMaxDateTimestamp)(
       proof.committedInputs?.compare_birthdate
     );
     const currentDate = (0, import_utils.getCurrentDateFromCommittedInputs)(
@@ -1593,88 +1628,91 @@ var ZKPassport = class {
       if (queryResult.birthdate.gte && queryResult.birthdate.gte.result && minDate !== queryResult.birthdate.gte.expected) {
         console.warn("Birthdate is not greater than or equal to the expected birthdate");
         isCorrect = false;
-        queryResultErrors.birthdate.gte = {
-          expected: queryResult.birthdate.gte.expected,
-          received: minDate,
-          message: "Birthdate is not greater than or equal to the expected birthdate"
+        queryResultErrors.birthdate = {
+          ...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;
-        queryResultErrors.birthdate.lte = {
-          expected: queryResult.birthdate.lte.expected,
-          received: maxDate,
-          message: "Birthdate is not less than the expected birthdate"
+        queryResultErrors.birthdate = {
+          ...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 && (minDate !== queryResult.birthdate.range.expected[0] || maxDate !== queryResult.birthdate.range.expected[1])) {
           console.warn("Birthdate is not in the expected range");
           isCorrect = false;
-          queryResultErrors.birthdate.range = {
-            expected: queryResult.birthdate.range.expected,
-            received: [minDate, maxDate],
-            message: "Birthdate is not in the expected range"
+          queryResultErrors.birthdate = {
+            ...queryResultErrors.birthdate,
+            range: {
+              expected: queryResult.birthdate.range.expected,
+              received: [minDate, maxDate],
+              message: "Birthdate is not in the expected range"
+            }
           };
         }
       }
       if (!queryResult.birthdate.lte && !queryResult.birthdate.range && !(0, import_utils.areDatesEqual)(maxDate, DEFAULT_DATE_VALUE)) {
         console.warn("Maximum birthdate should be equal to default date value");
         isCorrect = false;
-        queryResultErrors.birthdate.disclose = {
-          expected: `${DEFAULT_DATE_VALUE.toISOString()}`,
-          received: `${maxDate.toISOString()}`,
-          message: "Maximum birthdate should be equal to default date value"
+        queryResultErrors.birthdate = {
+          ...queryResultErrors.birthdate,
+          disclose: {
+            expected: `${DEFAULT_DATE_VALUE.toISOString()}`,
+            received: `${maxDate.toISOString()}`,
+            message: "Maximum birthdate should be equal to default date value"
+          }
         };
       }
       if (!queryResult.birthdate.gte && !queryResult.birthdate.range && !(0, import_utils.areDatesEqual)(minDate, DEFAULT_DATE_VALUE)) {
         console.warn("Minimum birthdate should be equal to default date value");
         isCorrect = false;
-        queryResultErrors.birthdate.disclose = {
-          expected: `${DEFAULT_DATE_VALUE.toISOString()}`,
-          received: `${minDate.toISOString()}`,
-          message: "Minimum birthdate should be equal to default date value"
+        queryResultErrors.birthdate = {
+          ...queryResultErrors.birthdate,
+          disclose: {
+            expected: `${DEFAULT_DATE_VALUE.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;
-      queryResultErrors.birthdate.disclose = {
-        message: "Birthdate is not set in the query result"
+      queryResultErrors.birthdate = {
+        ...queryResultErrors.birthdate,
+        disclose: {
+          message: "Birthdate is not set in the query result"
+        }
       };
     }
     if (!(0, import_utils.areDatesEqual)(currentDate, today) && !(0, import_utils.areDatesEqual)(currentDate, today.getTime() - 864e5)) {
       console.warn("Current date in the proof is too old");
       isCorrect = false;
-      queryResultErrors.age.disclose = {
-        expected: `${today.toISOString()}`,
-        received: `${currentDate.toISOString()}`,
-        message: "Current date in the proof is too old"
+      queryResultErrors.birthdate = {
+        ...queryResultErrors.birthdate,
+        disclose: {
+          expected: `${today.toISOString()}`,
+          received: `${currentDate.toISOString()}`,
+          message: "Current date in the proof is too old"
+        }
       };
     }
     return { isCorrect, queryResultErrors };
   }
   checkExpiryDatePublicInputs(proof, queryResult) {
-    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: {},
-      outer: {},
-      bind: {}
-    };
+    const queryResultErrors = {};
     let isCorrect = true;
     const currentTime = /* @__PURE__ */ new Date();
     const today = new Date(
@@ -1698,104 +1736,113 @@ var ZKPassport = class {
       if (queryResult.expiry_date.gte && queryResult.expiry_date.gte.result && minDate !== queryResult.expiry_date.gte.expected) {
         console.warn("Expiry date is not greater than or equal to the expected expiry date");
         isCorrect = false;
-        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"
+        queryResultErrors.expiry_date = {
+          ...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;
-        queryResultErrors.expiry_date.lte = {
-          expected: queryResult.expiry_date.lte.expected,
-          received: maxDate,
-          message: "Expiry date is not less than the expected expiry date"
+        queryResultErrors.expiry_date = {
+          ...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 && (minDate !== queryResult.expiry_date.range.expected[0] || maxDate !== queryResult.expiry_date.range.expected[1])) {
           console.warn("Expiry date is not in the expected range");
           isCorrect = false;
-          queryResultErrors.expiry_date.range = {
-            expected: queryResult.expiry_date.range.expected,
-            received: [minDate, maxDate],
-            message: "Expiry date is not in the expected range"
+          queryResultErrors.expiry_date = {
+            ...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 && !queryResult.expiry_date.range && !(0, import_utils.areDatesEqual)(maxDate, DEFAULT_DATE_VALUE)) {
         console.warn("Maximum expiry date should be equal to default date value");
         isCorrect = false;
-        queryResultErrors.expiry_date.disclose = {
-          expected: `${DEFAULT_DATE_VALUE.toISOString()}`,
-          received: `${maxDate.toISOString()}`,
-          message: "Maximum expiry date should be equal to default date value"
+        queryResultErrors.expiry_date = {
+          ...queryResultErrors.expiry_date,
+          disclose: {
+            expected: `${DEFAULT_DATE_VALUE.toISOString()}`,
+            received: `${maxDate.toISOString()}`,
+            message: "Maximum expiry date should be equal to default date value"
+          }
         };
       }
       if (!queryResult.expiry_date.gte && !queryResult.expiry_date.range && !(0, import_utils.areDatesEqual)(minDate, DEFAULT_DATE_VALUE)) {
         console.warn("Minimum expiry date should be equal to default date value");
         isCorrect = false;
-        queryResultErrors.expiry_date.disclose = {
-          expected: `${DEFAULT_DATE_VALUE.toISOString()}`,
-          received: `${minDate.toISOString()}`,
-          message: "Minimum expiry date should be equal to default date value"
+        queryResultErrors.expiry_date = {
+          ...queryResultErrors.expiry_date,
+          disclose: {
+            expected: `${DEFAULT_DATE_VALUE.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;
-      queryResultErrors.expiry_date.disclose = {
-        message: "Expiry date is not set in the query result"
+      queryResultErrors.expiry_date = {
+        ...queryResultErrors.expiry_date,
+        disclose: {
+          message: "Expiry date is not set in the query result"
+        }
       };
     }
     if (!(0, import_utils.areDatesEqual)(currentDate, today) && !(0, import_utils.areDatesEqual)(currentDate, today.getTime() - 864e5)) {
       console.warn("Current date in the proof is too old");
       isCorrect = false;
-      queryResultErrors.age.disclose = {
-        expected: `${today.toISOString()}`,
-        received: `${currentDate.toISOString()}`,
-        message: "Current date in the proof is too old"
+      queryResultErrors.expiry_date = {
+        ...queryResultErrors.expiry_date,
+        disclose: {
+          expected: `${today.toISOString()}`,
+          received: `${currentDate.toISOString()}`,
+          message: "Current date in the proof is too old"
+        }
       };
     }
     return { isCorrect, queryResultErrors };
   }
   checkNationalityExclusionPublicInputs(queryResult, countryList) {
-    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: {},
-      outer: {},
-      bind: {}
-    };
+    const queryResultErrors = {};
     let isCorrect = true;
     if (queryResult.nationality && queryResult.nationality.out && queryResult.nationality.out.result) {
       if (!queryResult.nationality.out.expected?.every((country) => countryList.includes(country))) {
         console.warn("Nationality exclusion list does not match the one from the query results");
         isCorrect = false;
-        queryResultErrors.nationality.out = {
-          expected: queryResult.nationality.out.expected,
-          received: countryList,
-          message: "Nationality exclusion list does not match the one from the query results"
+        queryResultErrors.nationality = {
+          ...queryResultErrors.nationality,
+          out: {
+            expected: queryResult.nationality.out.expected,
+            received: countryList,
+            message: "Nationality 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;
-      queryResultErrors.nationality.out = {
-        message: "Nationality exclusion is not set in the query result"
+      queryResultErrors.nationality = {
+        ...queryResultErrors.nationality,
+        out: {
+          message: "Nationality exclusion is not set in the query result"
+        }
       };
     }
     for (let i = 1; i < countryList.length; i++) {
@@ -1804,49 +1851,40 @@ var ZKPassport = class {
           "The nationality exclusion list has not been sorted, and thus the proof cannot be trusted"
         );
         isCorrect = false;
-        queryResultErrors.nationality.out = {
-          message: "The nationality exclusion list has not been sorted, and thus the proof cannot be trusted"
+        queryResultErrors.nationality = {
+          ...queryResultErrors.nationality,
+          out: {
+            message: "The nationality exclusion list has not been sorted, and thus the proof cannot be trusted"
+          }
         };
       }
     }
     return { isCorrect, queryResultErrors };
   }
   checkIssuingCountryExclusionPublicInputs(queryResult, countryList) {
-    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: {},
-      outer: {},
-      bind: {}
-    };
+    const queryResultErrors = {};
     let isCorrect = true;
     if (queryResult.issuing_country && queryResult.issuing_country.out && queryResult.issuing_country.out.result) {
       if (!queryResult.issuing_country.out.expected?.every((country) => countryList.includes(country))) {
         console.warn("Issuing country exclusion list does not match the one from the query results");
         isCorrect = false;
-        queryResultErrors.issuing_country.out = {
-          expected: queryResult.issuing_country.out.expected,
-          received: countryList,
-          message: "Issuing country exclusion list does not match the one from the query results"
+        queryResultErrors.issuing_country = {
+          ...queryResultErrors.issuing_country,
+          out: {
+            expected: queryResult.issuing_country.out.expected,
+            received: countryList,
+            message: "Issuing country exclusion list does not match the one from the query results"
+          }
         };
       }
     } else if (!queryResult.issuing_country || !queryResult.issuing_country.out) {
       console.warn("Issuing country exclusion is not set in the query result");
       isCorrect = false;
-      queryResultErrors.issuing_country.out = {
-        message: "Issuing country exclusion is not set in the query result"
+      queryResultErrors.issuing_country = {
+        ...queryResultErrors.issuing_country,
+        out: {
+          message: "Issuing country exclusion is not set in the query result"
+        }
       };
     }
     for (let i = 1; i < countryList.length; i++) {
@@ -1855,98 +1893,80 @@ var ZKPassport = class {
           "The issuing country exclusion list has not been sorted, and thus the proof cannot be trusted"
         );
         isCorrect = false;
-        queryResultErrors.issuing_country.out = {
-          message: "The issuing country exclusion list has not been sorted, and thus the proof cannot be trusted"
+        queryResultErrors.issuing_country = {
+          ...queryResultErrors.issuing_country,
+          out: {
+            message: "The issuing country exclusion list has not been sorted, and thus the proof cannot be trusted"
+          }
         };
       }
     }
     return { isCorrect, queryResultErrors };
   }
   checkNationalityInclusionPublicInputs(queryResult, countryList) {
-    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: {},
-      outer: {},
-      bind: {}
-    };
+    const queryResultErrors = {};
     let isCorrect = true;
     if (queryResult.nationality && queryResult.nationality.in && queryResult.nationality.in.result) {
       if (!queryResult.nationality.in.expected?.every((country) => countryList.includes(country))) {
         console.warn("Nationality inclusion list does not match the one from the query results");
         isCorrect = false;
-        queryResultErrors.nationality.in = {
-          expected: queryResult.nationality.in.expected,
-          received: countryList,
-          message: "Nationality inclusion list does not match the one from the query results"
+        queryResultErrors.nationality = {
+          ...queryResultErrors.nationality,
+          in: {
+            expected: queryResult.nationality.in.expected,
+            received: countryList,
+            message: "Nationality 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;
-      queryResultErrors.nationality.in = {
-        message: "Nationality inclusion is not set in the query result"
+      queryResultErrors.nationality = {
+        ...queryResultErrors.nationality,
+        in: {
+          message: "Nationality inclusion is not set in the query result"
+        }
       };
     }
     return { isCorrect, queryResultErrors };
   }
   checkIssuingCountryInclusionPublicInputs(queryResult, countryList) {
-    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: {},
-      outer: {},
-      bind: {}
-    };
+    const queryResultErrors = {};
     let isCorrect = true;
     if (queryResult.issuing_country && queryResult.issuing_country.in && queryResult.issuing_country.in.result) {
       if (!queryResult.issuing_country.in.expected?.every((country) => countryList.includes(country))) {
         console.warn("Issuing country inclusion list does not match the one from the query results");
         isCorrect = false;
-        queryResultErrors.issuing_country.in = {
-          expected: queryResult.issuing_country.in.expected,
-          received: countryList,
-          message: "Issuing country inclusion list does not match the one from the query results"
+        queryResultErrors.issuing_country = {
+          ...queryResultErrors.issuing_country,
+          in: {
+            expected: queryResult.issuing_country.in.expected,
+            received: countryList,
+            message: "Issuing country inclusion list does not match the one from the query results"
+          }
         };
       }
     } else if (!queryResult.issuing_country || !queryResult.issuing_country.in) {
       console.warn("Issuing country inclusion is not set in the query result");
       isCorrect = false;
-      queryResultErrors.issuing_country.in = {
-        message: "Issuing country inclusion is not set in the query result"
+      queryResultErrors.issuing_country = {
+        ...queryResultErrors.issuing_country,
+        in: {
+          message: "Issuing country inclusion is not set in the query result"
+        }
       };
     }
     return { isCorrect, queryResultErrors };
   }
-  checkScopeFromDisclosureProof(proofData, queryResultErrors, key, scope, chainId) {
+  checkScopeFromDisclosureProof(proofData, queryResultErrors, key, scope) {
     let isCorrect = true;
     if (this.domain && (0, import_utils.getServiceScopeHash)(this.domain) !== BigInt(proofData.publicInputs[1])) {
       console.warn("The proof comes from a different domain than the one expected");
       isCorrect = false;
+      if (!queryResultErrors[key]) {
+        queryResultErrors[key] = {};
+      }
       queryResultErrors[key].scope = {
         expected: `Scope: ${(0, import_utils.getServiceScopeHash)(this.domain).toString()}`,
         received: `Scope: ${BigInt(proofData.publicInputs[1]).toString()}`,
@@ -1956,6 +1976,9 @@ var ZKPassport = class {
     if (scope && (0, import_utils.getScopeHash)(scope) !== BigInt(proofData.publicInputs[2])) {
       console.warn("The proof uses a different scope than the one expected");
       isCorrect = false;
+      if (!queryResultErrors[key]) {
+        queryResultErrors[key] = {};
+      }
       queryResultErrors[key].scope = {
         expected: `Scope: ${(0, import_utils.getScopeHash)(scope).toString()}`,
         received: `Scope: ${BigInt(proofData.publicInputs[2]).toString()}`,
@@ -1972,6 +1995,9 @@ var ZKPassport = class {
       if (!isValid) {
         console.warn("The ID was signed by an unrecognized root certificate");
         isCorrect = false;
+        if (!queryResultErrors[outer ? "outer" : "sig_check_dsc"]) {
+          queryResultErrors[outer ? "outer" : "sig_check_dsc"] = {};
+        }
         queryResultErrors[outer ? "outer" : "sig_check_dsc"].certificate = {
           expected: `A valid root from ZKPassport Registry`,
           received: `Got invalid certificate registry root: ${root}`,
@@ -1982,6 +2008,9 @@ var ZKPassport = class {
       console.warn(error);
       console.warn("The ID was signed by an unrecognized root certificate");
       isCorrect = false;
+      if (!queryResultErrors[outer ? "outer" : "sig_check_dsc"]) {
+        queryResultErrors[outer ? "outer" : "sig_check_dsc"] = {};
+      }
       queryResultErrors[outer ? "outer" : "sig_check_dsc"].certificate = {
         expected: `A valid root from ZKPassport Registry`,
         received: `Got invalid certificate registry root: ${root}`,
@@ -2017,52 +2046,63 @@ var ZKPassport = class {
     return { isCorrect, queryResultErrors };
   }
   checkBindPublicInputs(queryResult, boundData) {
-    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: {},
-      outer: {},
-      bind: {}
-    };
+    const queryResultErrors = {};
     let isCorrect = true;
     if (queryResult.bind) {
       if (queryResult.bind.user_address?.toLowerCase().replace("0x", "") !== boundData.user_address?.toLowerCase().replace("0x", "")) {
         console.warn("Bound user address does not match the one from the query results");
         isCorrect = false;
-        queryResultErrors.bind.eq = {
-          expected: queryResult.bind.user_address,
-          received: boundData.user_address,
-          message: "Bound user address does not match the one from the query results"
+        queryResultErrors.bind = {
+          ...queryResultErrors.bind,
+          eq: {
+            expected: queryResult.bind.user_address,
+            received: boundData.user_address,
+            message: "Bound user address does not match the one from the query results"
+          }
         };
       }
       if (queryResult.bind.chain !== boundData.chain) {
         console.warn("Bound chain id does not match the one from the query results");
         isCorrect = false;
-        queryResultErrors.bind.eq = {
-          expected: queryResult.bind.chain,
-          received: boundData.chain,
-          message: "Bound chain id does not match the one from the query results"
+        queryResultErrors.bind = {
+          ...queryResultErrors.bind,
+          eq: {
+            expected: queryResult.bind.chain,
+            received: boundData.chain,
+            message: "Bound chain id does not match the one from the query results"
+          }
         };
       }
       if (queryResult.bind.custom_data?.trim().toLowerCase() !== boundData.custom_data?.trim().toLowerCase()) {
         console.warn("Bound custom data does not match the one from the query results");
         isCorrect = false;
-        queryResultErrors.bind.eq = {
-          expected: queryResult.bind.custom_data,
-          received: boundData.custom_data,
-          message: "Bound custom data does not match the one from the query results"
+        queryResultErrors.bind = {
+          ...queryResultErrors.bind,
+          eq: {
+            expected: queryResult.bind.custom_data,
+            received: boundData.custom_data,
+            message: "Bound custom data does not match the one from the query results"
+          }
+        };
+      }
+    }
+    return { isCorrect, queryResultErrors };
+  }
+  async checkSanctionsExclusionPublicInputs(queryResult, root, sanctionsBuilder) {
+    const queryResultErrors = {};
+    let isCorrect = true;
+    if (queryResult.sanctions && queryResult.sanctions.passed) {
+      const EXPECTED_ROOT = await sanctionsBuilder.getRoot();
+      if (root !== BigInt(EXPECTED_ROOT)) {
+        console.warn("Invalid sanctions registry root");
+        isCorrect = false;
+        queryResultErrors.sanctions = {
+          ...queryResultErrors.sanctions,
+          eq: {
+            expected: EXPECTED_ROOT,
+            received: root.toString(16),
+            message: "Invalid sanctions registry root"
+          }
         };
       }
     }
@@ -2083,25 +2123,7 @@ var ZKPassport = class {
       0,
       0
     );
-    let 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: {},
-      outer: {},
-      bind: {}
-    };
+    let queryResultErrors = {};
     const sortedProofs = proofs.sort((a, b) => {
       const proofOrder = [
         "sig_check_dsc",
@@ -2115,7 +2137,8 @@ var ZKPassport = class {
         "inclusion_check_nationality",
         "exclusion_check_issuing_country",
         "inclusion_check_issuing_country",
-        "bind"
+        "bind",
+        "exclusion_check_sanctions"
       ];
       const getIndex = (proof) => {
         const name = proof.name || "";
@@ -2153,18 +2176,20 @@ var ZKPassport = class {
         };
         const currentDate = (0, import_utils.getCurrentDateFromOuterProof)(proofData);
         const todayToCurrentDate = today.getTime() - currentDate.getTime();
-        const differenceInDays = validity ?? 180;
-        const expectedDifference = differenceInDays * 864e5;
+        const expectedDifference = validity ? validity * 1e3 : DEFAULT_VALIDITY * 1e3;
         const actualDifference = today.getTime() - (today.getTime() - expectedDifference);
         if (todayToCurrentDate >= actualDifference) {
           console.warn(
-            `The date used to check the validity of the ID is older than ${differenceInDays} days. You can ask the user to rescan their ID or ask them to disclose their expiry date`
+            `The date used to check the validity of the ID is older than the validity period`
           );
           isCorrect = false;
-          queryResultErrors.outer.date = {
-            expected: `Difference: ${differenceInDays} days`,
-            received: `Difference: ${Math.round(todayToCurrentDate / 864e5)} days`,
-            message: "The date used to check the validity of the ID is older than the validity period"
+          queryResultErrors.outer = {
+            ...queryResultErrors.outer,
+            date: {
+              expected: `Difference: ${validity} seconds`,
+              received: `Difference: ${Math.round(todayToCurrentDate / 1e3)} seconds`,
+              message: "The date used to check the validity of the ID is older than the validity period"
+            }
           };
         }
         const paramCommitments = (0, import_utils.getParamCommitmentsFromOuterProof)(proofData);
@@ -2173,28 +2198,37 @@ var ZKPassport = class {
         if (keysInCommittedInputs.length !== paramCommitments.length) {
           console.warn("The proof does not verify all the requested conditions and information");
           isCorrect = false;
-          queryResultErrors.outer.commitment = {
-            expected: `Number of parameter commitments: ${paramCommitments.length}`,
-            received: `Number of disclosure proofs provided: ${keysInCommittedInputs.length}`,
-            message: "The proof does not verify all the requested conditions and information"
+          queryResultErrors.outer = {
+            ...queryResultErrors.outer,
+            commitment: {
+              expected: `Number of parameter commitments: ${paramCommitments.length}`,
+              received: `Number of disclosure proofs provided: ${keysInCommittedInputs.length}`,
+              message: "The proof does not verify all the requested conditions and information"
+            }
           };
         }
         if (this.domain && (0, import_utils.getServiceScopeHash)(this.domain) !== (0, import_utils.getScopeFromOuterProof)(proofData)) {
           console.warn("The proof comes from a different domain than the one expected");
           isCorrect = false;
-          queryResultErrors.outer.scope = {
-            expected: `Scope: ${(0, import_utils.getServiceScopeHash)(this.domain).toString()}`,
-            received: `Scope: ${(0, import_utils.getScopeFromOuterProof)(proofData).toString()}`,
-            message: "The proof comes from a different domain than the one expected"
+          queryResultErrors.outer = {
+            ...queryResultErrors.outer,
+            scope: {
+              expected: `Scope: ${(0, import_utils.getServiceScopeHash)(this.domain).toString()}`,
+              received: `Scope: ${(0, import_utils.getScopeFromOuterProof)(proofData).toString()}`,
+              message: "The proof comes from a different domain than the one expected"
+            }
           };
         }
         if (scope && (0, import_utils.getScopeHash)(scope) !== (0, import_utils.getSubscopeFromOuterProof)(proofData)) {
           console.warn("The proof uses a different scope than the one expected");
           isCorrect = false;
-          queryResultErrors.outer.scope = {
-            expected: `Scope: ${(0, import_utils.getScopeHash)(scope).toString()}`,
-            received: `Scope: ${(0, import_utils.getSubscopeFromOuterProof)(proofData).toString()}`,
-            message: "The proof uses a different scope than the one expected"
+          queryResultErrors.outer = {
+            ...queryResultErrors.outer,
+            scope: {
+              expected: `Scope: ${(0, import_utils.getScopeHash)(scope).toString()}`,
+              received: `Scope: ${(0, import_utils.getSubscopeFromOuterProof)(proofData).toString()}`,
+              message: "The proof uses a different scope than the one expected"
+            }
           };
         }
         if (!!committedInputs?.compare_age) {
@@ -2211,10 +2245,13 @@ var ZKPassport = class {
           if (!paramCommitments.includes(ageParameterCommitment)) {
             console.warn("This proof does not verify the age");
             isCorrect = false;
-            queryResultErrors.age.commitment = {
-              expected: `Age parameter commitment: ${ageParameterCommitment.toString()}`,
-              received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
-              message: "This proof does not verify the age"
+            queryResultErrors.age = {
+              ...queryResultErrors.age,
+              commitment: {
+                expected: `Age parameter commitment: ${ageParameterCommitment.toString()}`,
+                received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
+                message: "This proof does not verify the age"
+              }
             };
           }
           const { isCorrect: isCorrectAge, queryResultErrors: queryResultErrorsAge } = this.checkAgePublicInputs(proof, queryResult);
@@ -2239,10 +2276,13 @@ var ZKPassport = class {
           if (!paramCommitments.includes(birthdateParameterCommitment)) {
             console.warn("This proof does not verify the birthdate");
             isCorrect = false;
-            queryResultErrors.birthdate.commitment = {
-              expected: `Birthdate parameter commitment: ${birthdateParameterCommitment.toString()}`,
-              received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
-              message: "This proof does not verify the birthdate"
+            queryResultErrors.birthdate = {
+              ...queryResultErrors.birthdate,
+              commitment: {
+                expected: `Birthdate parameter commitment: ${birthdateParameterCommitment.toString()}`,
+                received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
+                message: "This proof does not verify the birthdate"
+              }
             };
           }
           const { isCorrect: isCorrectBirthdate, queryResultErrors: queryResultErrorsBirthdate } = this.checkBirthdatePublicInputs(proof, queryResult);
@@ -2267,10 +2307,13 @@ var ZKPassport = class {
           if (!paramCommitments.includes(expiryParameterCommitment)) {
             console.warn("This proof does not verify the expiry date");
             isCorrect = false;
-            queryResultErrors.expiry_date.commitment = {
-              expected: `Expiry date parameter commitment: ${expiryParameterCommitment.toString()}`,
-              received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
-              message: "This proof does not verify the expiry date"
+            queryResultErrors.expiry_date = {
+              ...queryResultErrors.expiry_date,
+              commitment: {
+                expected: `Expiry date parameter commitment: ${expiryParameterCommitment.toString()}`,
+                received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
+                message: "This proof does not verify the expiry date"
+              }
             };
           }
           const { isCorrect: isCorrectExpiryDate, queryResultErrors: queryResultErrorsExpiryDate } = this.checkExpiryDatePublicInputs(proof, queryResult);
@@ -2291,10 +2334,13 @@ var ZKPassport = class {
           if (!paramCommitments.includes(discloseParameterCommitment)) {
             console.warn("This proof does not verify any of the data disclosed");
             isCorrect = false;
-            queryResultErrors.disclose.commitment = {
-              expected: `Disclosure parameter commitment: ${discloseParameterCommitment.toString()}`,
-              received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
-              message: "This proof does not verify any of the data disclosed"
+            queryResultErrors.disclose = {
+              ...queryResultErrors.disclose,
+              commitment: {
+                expected: `Disclosure parameter commitment: ${discloseParameterCommitment.toString()}`,
+                received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
+                message: "This proof does not verify any of the data disclosed"
+              }
             };
           }
           const { isCorrect: isCorrectDisclose, queryResultErrors: queryResultErrorsDisclose } = this.checkDiscloseBytesPublicInputs(proof, queryResult);
@@ -2315,10 +2361,13 @@ var ZKPassport = class {
           if (!paramCommitments.includes(inclusionCheckNationalityParameterCommitment)) {
             console.warn("This proof does not verify the inclusion of the nationality");
             isCorrect = false;
-            queryResultErrors.nationality.commitment = {
-              expected: `Nationality parameter commitment: ${inclusionCheckNationalityParameterCommitment.toString()}`,
-              received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
-              message: "This proof does not verify the inclusion of the nationality"
+            queryResultErrors.nationality = {
+              ...queryResultErrors.nationality,
+              commitment: {
+                expected: `Nationality parameter commitment: ${inclusionCheckNationalityParameterCommitment.toString()}`,
+                received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
+                message: "This proof does not verify the inclusion of the nationality"
+              }
             };
           }
           const countryList = inclusionCheckNationalityCommittedInputs.countries;
@@ -2343,10 +2392,13 @@ var ZKPassport = class {
           if (!paramCommitments.includes(inclusionCheckIssuingCountryParameterCommitment)) {
             console.warn("This proof does not verify the inclusion of the issuing country");
             isCorrect = false;
-            queryResultErrors.issuing_country.commitment = {
-              expected: `Issuing country parameter commitment: ${inclusionCheckIssuingCountryParameterCommitment.toString()}`,
-              received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
-              message: "This proof does not verify the inclusion of the issuing country"
+            queryResultErrors.issuing_country = {
+              ...queryResultErrors.issuing_country,
+              commitment: {
+                expected: `Issuing country parameter commitment: ${inclusionCheckIssuingCountryParameterCommitment.toString()}`,
+                received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
+                message: "This proof does not verify the inclusion of the issuing country"
+              }
             };
           }
           const countryList = inclusionCheckIssuingCountryCommittedInputs.countries;
@@ -2371,10 +2423,13 @@ var ZKPassport = class {
           if (!paramCommitments.includes(exclusionCheckNationalityParameterCommitment)) {
             console.warn("This proof does not verify the exclusion of the nationality");
             isCorrect = false;
-            queryResultErrors.nationality.commitment = {
-              expected: `Nationality parameter commitment: ${exclusionCheckNationalityParameterCommitment.toString()}`,
-              received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
-              message: "This proof does not verify the exclusion of the nationality"
+            queryResultErrors.nationality = {
+              ...queryResultErrors.nationality,
+              commitment: {
+                expected: `Nationality parameter commitment: ${exclusionCheckNationalityParameterCommitment.toString()}`,
+                received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
+                message: "This proof does not verify the exclusion of the nationality"
+              }
             };
           }
           const countryList = exclusionCheckNationalityCommittedInputs.countries;
@@ -2399,10 +2454,13 @@ var ZKPassport = class {
           if (!paramCommitments.includes(exclusionCheckIssuingCountryParameterCommitment)) {
             console.warn("This proof does not verify the exclusion of the issuing country");
             isCorrect = false;
-            queryResultErrors.issuing_country.commitment = {
-              expected: `Issuing country parameter commitment: ${exclusionCheckIssuingCountryParameterCommitment.toString()}`,
-              received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
-              message: "This proof does not verify the exclusion of the issuing country"
+            queryResultErrors.issuing_country = {
+              ...queryResultErrors.issuing_country,
+              commitment: {
+                expected: `Issuing country parameter commitment: ${exclusionCheckIssuingCountryParameterCommitment.toString()}`,
+                received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
+                message: "This proof does not verify the exclusion of the issuing country"
+              }
             };
           }
           const countryList = exclusionCheckIssuingCountryCommittedInputs.countries;
@@ -2421,10 +2479,13 @@ var ZKPassport = class {
           if (!paramCommitments.includes(bindParameterCommitment)) {
             console.warn("This proof does not verify the bound data");
             isCorrect = false;
-            queryResultErrors.bind.commitment = {
-              expected: `Bind parameter commitment: ${bindParameterCommitment.toString()}`,
-              received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
-              message: "This proof does not verify the bound data"
+            queryResultErrors.bind = {
+              ...queryResultErrors.bind,
+              commitment: {
+                expected: `Bind parameter commitment: ${bindParameterCommitment.toString()}`,
+                received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
+                message: "This proof does not verify the bound data"
+              }
             };
           }
           const { isCorrect: isCorrectBind, queryResultErrors: queryResultErrorsBind } = this.checkBindPublicInputs(queryResult, bindCommittedInputs.data);
@@ -2433,6 +2494,35 @@ var ZKPassport = class {
             ...queryResultErrors,
             ...queryResultErrorsBind
           };
+        } else if (!!committedInputs?.exclusion_check_sanctions) {
+          const sanctionsBuilder = await import_utils.SanctionsBuilder.create();
+          const exclusionCheckSanctionsCommittedInputs = committedInputs?.exclusion_check_sanctions;
+          const exclusionCheckSanctionsParameterCommitment = isForEVM ? await sanctionsBuilder.getSanctionsEvmParameterCommitment() : await sanctionsBuilder.getSanctionsParameterCommitment();
+          if (!paramCommitments.includes(exclusionCheckSanctionsParameterCommitment)) {
+            console.warn("This proof does not verify the exclusion from the sanction lists");
+            isCorrect = false;
+            queryResultErrors.sanctions = {
+              ...queryResultErrors.sanctions,
+              commitment: {
+                expected: `Sanctions parameter commitment: ${exclusionCheckSanctionsParameterCommitment.toString()}`,
+                received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
+                message: "This proof does not verify the exclusion from the sanction lists"
+              }
+            };
+          }
+          const {
+            isCorrect: isCorrectSanctionsExclusion,
+            queryResultErrors: queryResultErrorsSanctionsExclusion
+          } = await this.checkSanctionsExclusionPublicInputs(
+            queryResult,
+            BigInt(exclusionCheckSanctionsCommittedInputs.rootHash),
+            sanctionsBuilder
+          );
+          isCorrect = isCorrect && isCorrectSanctionsExclusion;
+          queryResultErrors = {
+            ...queryResultErrors,
+            ...queryResultErrorsSanctionsExclusion
+          };
         }
         uniqueIdentifier = (0, import_utils.getNullifierFromOuterProof)(proofData).toString(10);
       } else if (proof.name?.startsWith("sig_check_dsc")) {
@@ -2458,10 +2548,13 @@ var ZKPassport = class {
             "Failed to check the link between the certificate signature and ID signature"
           );
           isCorrect = false;
-          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"
+          queryResultErrors.sig_check_id_data = {
+            ...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 = (0, import_utils.getCommitmentOutFromIDDataProof)(proofData);
@@ -2470,27 +2563,32 @@ var ZKPassport = class {
         if (commitmentIn !== commitmentOut) {
           console.warn("Failed to check the link between the ID signature and the data signed");
           isCorrect = false;
-          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"
+          queryResultErrors.data_check_integrity = {
+            ...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 = (0, import_utils.getCommitmentOutFromIntegrityProof)(proofData);
         const currentDate = (0, import_utils.getCurrentDateFromIntegrityProof)(proofData);
         const todayToCurrentDate = today.getTime() - currentDate.getTime();
-        const differenceInDays = validity ?? 180;
-        const expectedDifference = differenceInDays * 864e5;
+        const expectedDifference = validity ? validity * 1e3 : DEFAULT_VALIDITY * 1e3;
         const actualDifference = today.getTime() - (today.getTime() - expectedDifference);
         if (todayToCurrentDate >= actualDifference) {
           console.warn(
-            `The date used to check the validity of the ID is older than ${differenceInDays} days. You can ask the user to rescan their ID or ask them to disclose their expiry date`
+            `The date used to check the validity of the ID is older than the validity period`
           );
           isCorrect = false;
-          queryResultErrors.data_check_integrity.date = {
-            expected: `Difference: ${differenceInDays} days`,
-            received: `Difference: ${Math.round(todayToCurrentDate / 864e5)} days`,
-            message: "The date used to check the validity of the ID is older than the validity period"
+          queryResultErrors.data_check_integrity = {
+            ...queryResultErrors.data_check_integrity,
+            date: {
+              expected: `Difference: ${validity} seconds`,
+              received: `Difference: ${Math.round(todayToCurrentDate / 1e3)} seconds`,
+              message: "The date used to check the validity of the ID is older than the validity period"
+            }
           };
         }
       } else if (proof.name === "disclose_bytes") {
@@ -2500,10 +2598,13 @@ var ZKPassport = class {
             "Failed to check the link between the validity of the ID and the data to disclose"
           );
           isCorrect = false;
-          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"
+          queryResultErrors.disclose = {
+            ...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"
+            }
           };
         }
         const paramCommitment = (0, import_utils.getParameterCommitmentFromDisclosureProof)(proofData);
@@ -2514,10 +2615,13 @@ var ZKPassport = class {
         if (paramCommitment !== calculatedParamCommitment) {
           console.warn("The disclosed data does not match the data committed by the proof");
           isCorrect = false;
-          queryResultErrors.disclose.commitment = {
-            expected: `Commitment: ${calculatedParamCommitment}`,
-            received: `Commitment: ${paramCommitment}`,
-            message: "The disclosed data does not match the data committed by the proof"
+          queryResultErrors.disclose = {
+            ...queryResultErrors.disclose,
+            commitment: {
+              expected: `Commitment: ${calculatedParamCommitment}`,
+              received: `Commitment: ${paramCommitment}`,
+              message: "The disclosed data does not match the data committed by the proof"
+            }
           };
         }
         const { isCorrect: isCorrectScope, queryResultErrors: queryResultErrorsScope } = this.checkScopeFromDisclosureProof(proofData, queryResultErrors, "disclose", scope);
@@ -2541,10 +2645,13 @@ var ZKPassport = class {
             "Failed to check the link between the validity of the ID and the age derived from it"
           );
           isCorrect = false;
-          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"
+          queryResultErrors.age = {
+            ...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 paramCommitment = (0, import_utils.getParameterCommitmentFromDisclosureProof)(proofData);
@@ -2559,10 +2666,13 @@ var ZKPassport = class {
             "The conditions for the age check do not match the conditions checked by the proof"
           );
           isCorrect = false;
-          queryResultErrors.age.commitment = {
-            expected: `Commitment: ${calculatedParamCommitment}`,
-            received: `Commitment: ${paramCommitment}`,
-            message: "The conditions for the age check do not match the conditions checked by the proof"
+          queryResultErrors.age = {
+            ...queryResultErrors.age,
+            commitment: {
+              expected: `Commitment: ${calculatedParamCommitment}`,
+              received: `Commitment: ${paramCommitment}`,
+              message: "The conditions for the age check do not match the conditions checked by the proof"
+            }
           };
         }
         const { isCorrect: isCorrectScope, queryResultErrors: queryResultErrorsScope } = this.checkScopeFromDisclosureProof(proofData, queryResultErrors, "age", scope);
@@ -2581,10 +2691,13 @@ var ZKPassport = class {
             "Failed to check the link between the validity of the ID and the birthdate derived from it"
           );
           isCorrect = false;
-          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"
+          queryResultErrors.birthdate = {
+            ...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 paramCommitment = (0, import_utils.getParameterCommitmentFromDisclosureProof)(proofData);
@@ -2600,10 +2713,13 @@ var ZKPassport = class {
             "The conditions for the birthdate check do not match the conditions checked by the proof"
           );
           isCorrect = false;
-          queryResultErrors.birthdate.commitment = {
-            expected: `Commitment: ${calculatedParamCommitment}`,
-            received: `Commitment: ${paramCommitment}`,
-            message: "The conditions for the birthdate check do not match the conditions checked by the proof"
+          queryResultErrors.birthdate = {
+            ...queryResultErrors.birthdate,
+            commitment: {
+              expected: `Commitment: ${calculatedParamCommitment}`,
+              received: `Commitment: ${paramCommitment}`,
+              message: "The conditions for the birthdate check do not match the conditions checked by the proof"
+            }
           };
         }
         const { isCorrect: isCorrectScope, queryResultErrors: queryResultErrorsScope } = this.checkScopeFromDisclosureProof(proofData, queryResultErrors, "birthdate", scope);
@@ -2622,10 +2738,13 @@ var ZKPassport = class {
             "Failed to check the link between the validity of the ID and its expiry date"
           );
           isCorrect = false;
-          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"
+          queryResultErrors.expiry_date = {
+            ...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 paramCommitment = (0, import_utils.getParameterCommitmentFromDisclosureProof)(proofData);
@@ -2641,10 +2760,13 @@ var ZKPassport = class {
             "The conditions for the expiry date check do not match the conditions checked by the proof"
           );
           isCorrect = false;
-          queryResultErrors.expiry_date.commitment = {
-            expected: `Commitment: ${calculatedParamCommitment}`,
-            received: `Commitment: ${paramCommitment}`,
-            message: "The conditions for the expiry date check do not match the conditions checked by the proof"
+          queryResultErrors.expiry_date = {
+            ...queryResultErrors.expiry_date,
+            commitment: {
+              expected: `Commitment: ${calculatedParamCommitment}`,
+              received: `Commitment: ${paramCommitment}`,
+              message: "The conditions for the expiry date check do not match the conditions checked by the proof"
+            }
           };
         }
         const { isCorrect: isCorrectScope, queryResultErrors: queryResultErrorsScope } = this.checkScopeFromDisclosureProof(proofData, queryResultErrors, "expiry_date", scope);
@@ -2663,10 +2785,13 @@ var ZKPassport = class {
             "Failed to check the link between the validity of the ID and the nationality exclusion check"
           );
           isCorrect = false;
-          queryResultErrors.nationality.commitment = {
-            expected: `Commitment: ${commitmentOut}`,
-            received: `Commitment: ${commitmentIn}`,
-            message: "Failed to check the link between the validity of the ID and the nationality exclusion check"
+          queryResultErrors.nationality = {
+            ...queryResultErrors.nationality,
+            commitment: {
+              expected: `Commitment: ${commitmentOut}`,
+              received: `Commitment: ${commitmentIn}`,
+              message: "Failed to check the link between the validity of the ID and the nationality exclusion check"
+            }
           };
         }
         const countryList = (proof.committedInputs?.exclusion_check_nationality).countries;
@@ -2681,10 +2806,13 @@ var ZKPassport = class {
             "The committed country list for the exclusion check does not match the one from the proof"
           );
           isCorrect = false;
-          queryResultErrors.nationality.commitment = {
-            expected: `Commitment: ${calculatedParamCommitment}`,
-            received: `Commitment: ${paramCommittment}`,
-            message: "The committed country list for the exclusion check does not match the one from the proof"
+          queryResultErrors.nationality = {
+            ...queryResultErrors.nationality,
+            commitment: {
+              expected: `Commitment: ${calculatedParamCommitment}`,
+              received: `Commitment: ${paramCommittment}`,
+              message: "The committed country list for the exclusion check does not match the one from the proof"
+            }
           };
         }
         const { isCorrect: isCorrectScope, queryResultErrors: queryResultErrorsScope } = this.checkScopeFromDisclosureProof(proofData, queryResultErrors, "nationality", scope);
@@ -2706,10 +2834,13 @@ var ZKPassport = class {
             "Failed to check the link between the validity of the ID and the issuing country exclusion check"
           );
           isCorrect = false;
-          queryResultErrors.nationality.commitment = {
-            expected: `Commitment: ${commitmentOut}`,
-            received: `Commitment: ${commitmentIn}`,
-            message: "Failed to check the link between the validity of the ID and the issuing country exclusion check"
+          queryResultErrors.nationality = {
+            ...queryResultErrors.nationality,
+            commitment: {
+              expected: `Commitment: ${commitmentOut}`,
+              received: `Commitment: ${commitmentIn}`,
+              message: "Failed to check the link between the validity of the ID and the issuing country exclusion check"
+            }
           };
         }
         const countryList = (proof.committedInputs?.exclusion_check_issuing_country).countries;
@@ -2724,10 +2855,13 @@ var ZKPassport = class {
             "The committed country list for the issuing country exclusion check does not match the one from the proof"
           );
           isCorrect = false;
-          queryResultErrors.issuing_country.commitment = {
-            expected: `Commitment: ${calculatedParamCommitment}`,
-            received: `Commitment: ${paramCommittment}`,
-            message: "The committed country list for the issuing country exclusion check does not match the one from the proof"
+          queryResultErrors.issuing_country = {
+            ...queryResultErrors.issuing_country,
+            commitment: {
+              expected: `Commitment: ${calculatedParamCommitment}`,
+              received: `Commitment: ${paramCommittment}`,
+              message: "The committed country list for the issuing country exclusion check does not match the one from the proof"
+            }
           };
         }
         const { isCorrect: isCorrectScope, queryResultErrors: queryResultErrorsScope } = this.checkScopeFromDisclosureProof(proofData, queryResultErrors, "nationality", scope);
@@ -2749,10 +2883,13 @@ var ZKPassport = class {
             "Failed to check the link between the validity of the ID and the nationality inclusion check"
           );
           isCorrect = false;
-          queryResultErrors.nationality.commitment = {
-            expected: `Commitment: ${commitmentOut}`,
-            received: `Commitment: ${commitmentIn}`,
-            message: "Failed to check the link between the validity of the ID and the nationality inclusion check"
+          queryResultErrors.nationality = {
+            ...queryResultErrors.nationality,
+            commitment: {
+              expected: `Commitment: ${commitmentOut}`,
+              received: `Commitment: ${commitmentIn}`,
+              message: "Failed to check the link between the validity of the ID and the nationality inclusion check"
+            }
           };
         }
         const countryList = (proof.committedInputs?.inclusion_check_nationality).countries;
@@ -2767,10 +2904,13 @@ var ZKPassport = class {
             "The committed country list for the nationality inclusion check does not match the one from the proof"
           );
           isCorrect = false;
-          queryResultErrors.nationality.commitment = {
-            expected: `Commitment: ${calculatedParamCommitment}`,
-            received: `Commitment: ${paramCommittment}`,
-            message: "The committed country list for the nationality inclusion check does not match the one from the proof"
+          queryResultErrors.nationality = {
+            ...queryResultErrors.nationality,
+            commitment: {
+              expected: `Commitment: ${calculatedParamCommitment}`,
+              received: `Commitment: ${paramCommittment}`,
+              message: "The committed country list for the nationality inclusion check does not match the one from the proof"
+            }
           };
         }
         const { isCorrect: isCorrectScope, queryResultErrors: queryResultErrorsScope } = this.checkScopeFromDisclosureProof(proofData, queryResultErrors, "nationality", scope);
@@ -2792,10 +2932,13 @@ var ZKPassport = class {
             "Failed to check the link between the validity of the ID and the issuing country inclusion check"
           );
           isCorrect = false;
-          queryResultErrors.nationality.commitment = {
-            expected: `Commitment: ${commitmentOut}`,
-            received: `Commitment: ${commitmentIn}`,
-            message: "Failed to check the link between the validity of the ID and the issuing country inclusion check"
+          queryResultErrors.nationality = {
+            ...queryResultErrors.nationality,
+            commitment: {
+              expected: `Commitment: ${commitmentOut}`,
+              received: `Commitment: ${commitmentIn}`,
+              message: "Failed to check the link between the validity of the ID and the issuing country inclusion check"
+            }
           };
         }
         const countryList = (proof.committedInputs?.inclusion_check_issuing_country).countries;
@@ -2810,10 +2953,13 @@ var ZKPassport = class {
             "The committed country list for the issuing country inclusion check does not match the one from the proof"
           );
           isCorrect = false;
-          queryResultErrors.issuing_country.commitment = {
-            expected: `Commitment: ${calculatedParamCommitment}`,
-            received: `Commitment: ${paramCommittment}`,
-            message: "The committed country list for the issuing country inclusion check does not match the one from the proof"
+          queryResultErrors.issuing_country = {
+            ...queryResultErrors.issuing_country,
+            commitment: {
+              expected: `Commitment: ${calculatedParamCommitment}`,
+              received: `Commitment: ${paramCommittment}`,
+              message: "The committed country list for the issuing country inclusion check does not match the one from the proof"
+            }
           };
         }
         const { isCorrect: isCorrectScope, queryResultErrors: queryResultErrorsScope } = this.checkScopeFromDisclosureProof(proofData, queryResultErrors, "nationality", scope);
@@ -2837,10 +2983,13 @@ var ZKPassport = class {
         if (paramCommittment !== calculatedParamCommitment) {
           console.warn("The bound data does not match the one from the proof");
           isCorrect = false;
-          queryResultErrors.bind.commitment = {
-            expected: `Commitment: ${calculatedParamCommitment}`,
-            received: `Commitment: ${paramCommittment}`,
-            message: "The bound data does not match the one from the proof"
+          queryResultErrors.bind = {
+            ...queryResultErrors.bind,
+            commitment: {
+              expected: `Commitment: ${calculatedParamCommitment}`,
+              received: `Commitment: ${paramCommittment}`,
+              message: "The bound data does not match the one from the proof"
+            }
           };
         }
         const { isCorrect: isCorrectBind, queryResultErrors: queryResultErrorsBind } = this.checkBindPublicInputs(queryResult, bindCommittedInputs.data);
@@ -2850,6 +2999,39 @@ var ZKPassport = class {
           ...queryResultErrorsBind
         };
         uniqueIdentifier = (0, import_utils.getNullifierFromDisclosureProof)(proofData).toString(10);
+      } else if (proof.name === "exclusion_check_sanctions") {
+        const sanctionsBuilder = await import_utils.SanctionsBuilder.create();
+        const exclusionCheckSanctionsCommittedInputs = proof.committedInputs?.exclusion_check_sanctions;
+        const calculatedParamCommitment = await sanctionsBuilder.getSanctionsParameterCommitment();
+        const paramCommittment = (0, import_utils.getParameterCommitmentFromDisclosureProof)(proofData);
+        if (paramCommittment !== calculatedParamCommitment) {
+          console.warn(
+            "The sanction lists check against do not match the sanction lists from the proof"
+          );
+          isCorrect = false;
+          queryResultErrors.sanctions = {
+            ...queryResultErrors.sanctions,
+            commitment: {
+              expected: `Commitment: ${calculatedParamCommitment.toString()}`,
+              received: `Commitment: ${paramCommittment.toString()}`,
+              message: "The sanction lists check against do not match the sanction lists from the proof"
+            }
+          };
+        }
+        const {
+          isCorrect: isCorrectSanctionsExclusion,
+          queryResultErrors: queryResultErrorsSanctionsExclusion
+        } = await this.checkSanctionsExclusionPublicInputs(
+          queryResult,
+          BigInt(exclusionCheckSanctionsCommittedInputs.rootHash),
+          sanctionsBuilder
+        );
+        isCorrect = isCorrect && isCorrectSanctionsExclusion;
+        queryResultErrors = {
+          ...queryResultErrors,
+          ...queryResultErrorsSanctionsExclusion
+        };
+        uniqueIdentifier = (0, import_utils.getNullifierFromDisclosureProof)(proofData).toString(10);
       }
     }
     return { isCorrect, uniqueIdentifier, queryResultErrors };
@@ -2858,7 +3040,7 @@ var ZKPassport = class {
    * @notice Verify the proofs received from the mobile app.
    * @param proofs The proofs to verify.
    * @param queryResult The query result to verify against
-   * @param validity How many days ago should have the ID been last scanned by the user?
+   * @param validity How many seconds ago the proof checking the expiry date of the ID should have been generated
    * @param scope Scope this request to a specific use case
    * @param devMode Whether to enable dev mode. This will allow you to verify mock proofs (i.e. from ZKR)
    * @param writingDirectory The directory (e.g. `./tmp`) where the necessary temporary artifacts for verification are written to.
@@ -2989,7 +3171,7 @@ var ZKPassport = class {
   }
   getSolidityVerifierParameters({
     proof,
-    validityPeriodInSeconds = 7 * 24 * 60 * 60,
+    validityPeriodInSeconds = DEFAULT_VALIDITY,
     domain,
     scope,
     devMode = false
@@ -3031,19 +3213,19 @@ var ZKPassport = class {
         ).map((x) => x.toString(16).padStart(2, "0")).join("");
       } else if (circuitName === "compare_age_evm") {
         const value = proof.committedInputs[circuitName];
-        const currentDateBytes = Array.from((0, import_utils2.numberToBytesBE)(value.currentDateTimestamp, 4));
+        const currentDateBytes = Array.from((0, import_utils2.numberToBytesBE)(value.currentDateTimestamp, 8));
         compressedCommittedInputs2 = import_utils.ProofType.AGE.toString(16).padStart(2, "0") + currentDateBytes.map((x) => x.toString(16).padStart(2, "0")).join("") + value.minAge.toString(16).padStart(2, "0") + value.maxAge.toString(16).padStart(2, "0");
       } else if (circuitName === "compare_birthdate_evm") {
         const value = proof.committedInputs[circuitName];
-        const currentDateBytes = Array.from((0, import_utils2.numberToBytesBE)(value.currentDateTimestamp, 4));
-        const minDateBytes = Array.from((0, import_utils2.numberToBytesBE)(value.minDateTimestamp, 4));
-        const maxDateBytes = Array.from((0, import_utils2.numberToBytesBE)(value.maxDateTimestamp, 4));
+        const currentDateBytes = Array.from((0, import_utils2.numberToBytesBE)(value.currentDateTimestamp, 8));
+        const minDateBytes = Array.from((0, import_utils2.numberToBytesBE)(value.minDateTimestamp, 8));
+        const maxDateBytes = Array.from((0, import_utils2.numberToBytesBE)(value.maxDateTimestamp, 8));
         compressedCommittedInputs2 = import_utils.ProofType.BIRTHDATE.toString(16).padStart(2, "0") + currentDateBytes.map((x) => x.toString(16).padStart(2, "0")).join("") + minDateBytes.map((x) => x.toString(16).padStart(2, "0")).join("") + maxDateBytes.map((x) => x.toString(16).padStart(2, "0")).join("");
       } else if (circuitName === "compare_expiry_evm") {
         const value = proof.committedInputs[circuitName];
-        const currentDateBytes = Array.from((0, import_utils2.numberToBytesBE)(value.currentDateTimestamp, 4));
-        const minDateBytes = Array.from((0, import_utils2.numberToBytesBE)(value.minDateTimestamp, 4));
-        const maxDateBytes = Array.from((0, import_utils2.numberToBytesBE)(value.maxDateTimestamp, 4));
+        const currentDateBytes = Array.from((0, import_utils2.numberToBytesBE)(value.currentDateTimestamp, 8));
+        const minDateBytes = Array.from((0, import_utils2.numberToBytesBE)(value.minDateTimestamp, 8));
+        const maxDateBytes = Array.from((0, import_utils2.numberToBytesBE)(value.maxDateTimestamp, 8));
         compressedCommittedInputs2 = import_utils.ProofType.EXPIRY_DATE.toString(16).padStart(2, "0") + currentDateBytes.map((x) => x.toString(16).padStart(2, "0")).join("") + minDateBytes.map((x) => x.toString(16).padStart(2, "0")).join("") + maxDateBytes.map((x) => x.toString(16).padStart(2, "0")).join("");
       } else if (circuitName === "disclose_bytes_evm") {
         const value = proof.committedInputs[circuitName];
@@ -3105,7 +3287,8 @@ var ZKPassport = class {
       "base64"
     );
     const pubkey = this.topicToPublicKey[requestId];
-    return `https://zkpassport.id/r?d=${this.domain}&t=${requestId}&c=${base64Config}&s=${base64Service}&p=${pubkey}&m=${this.topicToLocalConfig[requestId].mode}&v=${VERSION}`;
+    const timestamp = Math.floor(Date.now() / 1e3) - this.topicToLocalConfig[requestId].validity;
+    return `https://zkpassport.id/r?d=${this.domain}&t=${requestId}&c=${base64Config}&s=${base64Service}&p=${pubkey}&m=${this.topicToLocalConfig[requestId].mode}&v=${VERSION}&d=${timestamp}`;
   }
   /**
    * @notice Returns the URL of the request.