@zkpassport/sdk 0.7.1 → 0.8.0-beta.2

package/dist/cjs/index.cjs

@@ -813,8 +813,9 @@ var ZKPassportVerifier_default = {
 var import_registry = require("@zkpassport/registry");
 var import_bridge = require("@obsidion/bridge");
 var import_utils4 = require("@zkpassport/utils");
-var VERSION = "0.7.0";
-var DEFAULT_DATE_VALUE = new Date(1111, 10, 11);
+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];
@@ -967,6 +971,12 @@ var ZKPassport = class {
     if (this.topicToConfig[topic].bind) {
       neededCircuits.push("bind");
     }
+    if (this.topicToConfig[topic].sanctions) {
+      neededCircuits.push("exclusion_check_sanctions");
+    }
+    if (this.topicToConfig[topic].facematch) {
+      neededCircuits.push("facematch");
+    }
     this.topicToExpectedProofCount[topic] = neededCircuits.length === 0 ? 4 : 3 + neededCircuits.length;
     this.topicToFailedProofCount[topic] = 0;
   }
@@ -1072,6 +1082,27 @@ var ZKPassport = class {
         };
         return this.getZkPassportRequest(topic);
       },
+      sanctions: (countries = "all", lists = "all") => {
+        this.topicToConfig[topic].sanctions = {
+          ...this.topicToConfig[topic].sanctions,
+          countries: countries === "all" ? "all" : Array.isArray(countries) ? [
+            ...this.topicToConfig[topic].sanctions?.countries ?? [],
+            ...countries
+          ] : [
+            ...this.topicToConfig[topic].sanctions?.countries ?? [],
+            countries
+          ],
+          lists: lists === "all" ? "all" : Array.isArray(lists) ? [...this.topicToConfig[topic].sanctions?.lists ?? [], ...lists] : [...this.topicToConfig[topic].sanctions?.lists ?? [], lists]
+        };
+        return this.getZkPassportRequest(topic);
+      },
+      // TODO: Uncomment this when the facematch is ready
+      /*facematch: (mode: FacematchMode = "regular") => {
+        this.topicToConfig[topic].facematch = {
+          mode,
+        }
+        return this.getZkPassportRequest(topic)
+      },*/
       done: () => {
         this.setExpectedProofCount(topic);
         return {
@@ -1096,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.
    */
@@ -1131,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
     };
@@ -1161,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,
@@ -1193,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"
+          }
         };
       }
     }
@@ -1215,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"
+          }
         };
       }
     }
@@ -1237,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"
+          }
         };
       }
     }
@@ -1259,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"
+          }
         };
       }
     }
@@ -1281,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"
+          }
         };
       }
     }
@@ -1303,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"
+          }
         };
       }
     }
@@ -1325,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"
+          }
         };
       }
     }
@@ -1347,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"
+          }
         };
       }
     }
@@ -1369,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"
+          }
         };
       }
     }
@@ -1391,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(
@@ -1450,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)(
@@ -1516,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(
@@ -1554,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)(
@@ -1567,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(
@@ -1672,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++) {
@@ -1778,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++) {
@@ -1829,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()}`,
@@ -1930,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()}`,
@@ -1946,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}`,
@@ -1956,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}`,
@@ -1991,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"
+          }
         };
       }
     }
@@ -2057,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",
@@ -2089,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 || "";
@@ -2127,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);
@@ -2147,48 +2198,60 @@ 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) {
           const ageCommittedInputs = committedInputs?.compare_age;
           const ageParameterCommitment = isForEVM ? await (0, import_utils.getAgeEVMParameterCommitment)(
-            ageCommittedInputs.currentDate,
+            ageCommittedInputs.currentDateTimestamp,
             ageCommittedInputs.minAge,
             ageCommittedInputs.maxAge
           ) : await (0, import_utils.getAgeParameterCommitment)(
-            ageCommittedInputs.currentDate,
+            ageCommittedInputs.currentDateTimestamp,
             ageCommittedInputs.minAge,
             ageCommittedInputs.maxAge
           );
           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);
@@ -2201,22 +2264,25 @@ var ZKPassport = class {
           const birthdateCommittedInputs = committedInputs?.compare_birthdate;
           const birthdateParameterCommitment = isForEVM ? await (0, import_utils.getDateEVMParameterCommitment)(
             import_utils.ProofType.BIRTHDATE,
-            birthdateCommittedInputs.currentDate,
-            birthdateCommittedInputs.minDate,
-            birthdateCommittedInputs.maxDate
+            birthdateCommittedInputs.currentDateTimestamp,
+            birthdateCommittedInputs.minDateTimestamp,
+            birthdateCommittedInputs.maxDateTimestamp
           ) : await (0, import_utils.getDateParameterCommitment)(
             import_utils.ProofType.BIRTHDATE,
-            birthdateCommittedInputs.currentDate,
-            birthdateCommittedInputs.minDate,
-            birthdateCommittedInputs.maxDate
+            birthdateCommittedInputs.currentDateTimestamp,
+            birthdateCommittedInputs.minDateTimestamp,
+            birthdateCommittedInputs.maxDateTimestamp
           );
           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);
@@ -2229,22 +2295,25 @@ var ZKPassport = class {
           const expiryCommittedInputs = committedInputs?.compare_expiry;
           const expiryParameterCommitment = isForEVM ? await (0, import_utils.getDateEVMParameterCommitment)(
             import_utils.ProofType.EXPIRY_DATE,
-            expiryCommittedInputs.currentDate,
-            expiryCommittedInputs.minDate,
-            expiryCommittedInputs.maxDate
+            expiryCommittedInputs.currentDateTimestamp,
+            expiryCommittedInputs.minDateTimestamp,
+            expiryCommittedInputs.maxDateTimestamp
           ) : await (0, import_utils.getDateParameterCommitment)(
             import_utils.ProofType.EXPIRY_DATE,
-            expiryCommittedInputs.currentDate,
-            expiryCommittedInputs.minDate,
-            expiryCommittedInputs.maxDate
+            expiryCommittedInputs.currentDateTimestamp,
+            expiryCommittedInputs.minDateTimestamp,
+            expiryCommittedInputs.maxDateTimestamp
           );
           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);
@@ -2265,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);
@@ -2289,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;
@@ -2317,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;
@@ -2345,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;
@@ -2373,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;
@@ -2395,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);
@@ -2407,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")) {
@@ -2432,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);
@@ -2444,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") {
@@ -2474,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);
@@ -2488,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);
@@ -2515,16 +2645,19 @@ 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);
         const committedInputs = proof.committedInputs?.compare_age;
         const calculatedParamCommitment = await (0, import_utils.getAgeParameterCommitment)(
-          committedInputs.currentDate,
+          committedInputs.currentDateTimestamp,
           committedInputs.minAge,
           committedInputs.maxAge
         );
@@ -2533,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);
@@ -2555,29 +2691,35 @@ 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);
         const committedInputs = proof.committedInputs?.compare_birthdate;
         const calculatedParamCommitment = await (0, import_utils.getDateParameterCommitment)(
           import_utils.ProofType.BIRTHDATE,
-          committedInputs.currentDate,
-          committedInputs.minDate,
-          committedInputs.maxDate
+          committedInputs.currentDateTimestamp,
+          committedInputs.minDateTimestamp,
+          committedInputs.maxDateTimestamp
         );
         if (paramCommitment !== calculatedParamCommitment) {
           console.warn(
             "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);
@@ -2596,29 +2738,35 @@ 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);
         const committedInputs = proof.committedInputs?.compare_expiry;
         const calculatedParamCommitment = await (0, import_utils.getDateParameterCommitment)(
           import_utils.ProofType.EXPIRY_DATE,
-          committedInputs.currentDate,
-          committedInputs.minDate,
-          committedInputs.maxDate
+          committedInputs.currentDateTimestamp,
+          committedInputs.minDateTimestamp,
+          committedInputs.maxDateTimestamp
         );
         if (paramCommitment !== calculatedParamCommitment) {
           console.warn(
             "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);
@@ -2637,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;
@@ -2655,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);
@@ -2680,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;
@@ -2698,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);
@@ -2723,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;
@@ -2741,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);
@@ -2766,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;
@@ -2784,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);
@@ -2811,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);
@@ -2824,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 };
@@ -2832,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.
@@ -2963,7 +3171,7 @@ var ZKPassport = class {
   }
   getSolidityVerifierParameters({
     proof,
-    validityPeriodInDays = 7,
+    validityPeriodInSeconds = DEFAULT_VALIDITY,
     domain,
     scope,
     devMode = false
@@ -3005,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(new TextEncoder().encode(value.currentDate));
+        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(new TextEncoder().encode(value.currentDate));
-        const minDateBytes = Array.from(new TextEncoder().encode(value.minDate));
-        const maxDateBytes = Array.from(new TextEncoder().encode(value.maxDate));
+        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(new TextEncoder().encode(value.currentDate));
-        const minDateBytes = Array.from(new TextEncoder().encode(value.minDate));
-        const maxDateBytes = Array.from(new TextEncoder().encode(value.maxDate));
+        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];
@@ -3064,7 +3272,7 @@ var ZKPassport = class {
       publicInputs: proofData.publicInputs,
       committedInputs: `0x${compressedCommittedInputs}`,
       committedInputCounts: committedInputCountsArray,
-      validityPeriodInDays,
+      validityPeriodInSeconds,
       domain: domain ?? this.domain,
       scope: scope ?? "",
       devMode
@@ -3079,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.