@zkpassport/sdk 0.8.8 → 0.9.0

package/dist/cjs/public-input-checker.cjs

@@ -0,0 +1,2058 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/public-input-checker.ts
+var public_input_checker_exports = {};
+__export(public_input_checker_exports, {
+  PublicInputChecker: () => PublicInputChecker
+});
+module.exports = __toCommonJS(public_input_checker_exports);
+var import_utils = require("@zkpassport/utils");
+var import_registry = require("@zkpassport/registry");
+
+// src/constants.ts
+var DEFAULT_VALIDITY = 7 * 24 * 60 * 60;
+var DEFAULT_DATE_VALUE = /* @__PURE__ */ new Date(0);
+var ZKPASSPORT_APP_ID_HASH = "0x1fa73686cf510f8f85757b0602de0dd72a13e68ae2092462be8b72662e7f179b";
+var APPLE_APP_ATTEST_ROOT_KEY_HASH = "0x2532418a107c5306fa8308c22255792cf77e4a290cbce8a840a642a3e591340b";
+
+// src/public-input-checker.ts
+var PublicInputChecker = class {
+  static checkDiscloseBytesPublicInputs(proof, queryResult) {
+    const queryResultErrors = {};
+    let isCorrect = true;
+    const disclosedDataPassport = import_utils.DisclosedData.fromDisclosedBytes(
+      (proof.committedInputs?.disclose_bytes).disclosedBytes,
+      "passport"
+    );
+    const disclosedDataIDCard = import_utils.DisclosedData.fromDisclosedBytes(
+      (proof.committedInputs?.disclose_bytes).disclosedBytes,
+      "id_card"
+    );
+    if (queryResult.document_type) {
+      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 = {
+          ...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 = {
+          ...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"
+          }
+        };
+      }
+    }
+    if (queryResult.birthdate) {
+      const birthdatePassport = disclosedDataPassport.dateOfBirth;
+      const birthdateIDCard = disclosedDataIDCard.dateOfBirth;
+      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 = {
+          ...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 = {
+          ...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"
+          }
+        };
+      }
+    }
+    if (queryResult.expiry_date) {
+      const expiryDatePassport = disclosedDataPassport.dateOfExpiry;
+      const expiryDateIDCard = disclosedDataIDCard.dateOfExpiry;
+      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 = {
+          ...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 = {
+          ...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"
+          }
+        };
+      }
+    }
+    if (queryResult.nationality) {
+      const nationalityPassport = disclosedDataPassport.nationality;
+      const nationalityIDCard = disclosedDataIDCard.nationality;
+      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 = {
+          ...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 = {
+          ...queryResultErrors.nationality,
+          disclose: {
+            expected: `${queryResult.nationality.disclose.result}`,
+            received: `${nationalityPassport ?? nationalityIDCard}`,
+            message: "Nationality does not match the disclosed nationality in query result"
+          }
+        };
+      }
+    }
+    if (queryResult.document_number) {
+      const documentNumberPassport = disclosedDataPassport.documentNumber;
+      const documentNumberIDCard = disclosedDataIDCard.documentNumber;
+      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 = {
+          ...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 = {
+          ...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"
+          }
+        };
+      }
+    }
+    if (queryResult.gender) {
+      const genderPassport = disclosedDataPassport.gender;
+      const genderIDCard = disclosedDataIDCard.gender;
+      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 = {
+          ...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 = {
+          ...queryResultErrors.gender,
+          disclose: {
+            expected: `${queryResult.gender.disclose.result}`,
+            received: `${genderPassport ?? genderIDCard}`,
+            message: "Gender does not match the disclosed gender in query result"
+          }
+        };
+      }
+    }
+    if (queryResult.issuing_country) {
+      const issuingCountryPassport = disclosedDataPassport.issuingCountry;
+      const issuingCountryIDCard = disclosedDataIDCard.issuingCountry;
+      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 = {
+          ...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 = {
+          ...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"
+          }
+        };
+      }
+    }
+    if (queryResult.fullname) {
+      const fullnamePassport = disclosedDataPassport.name;
+      const fullnameIDCard = disclosedDataIDCard.name;
+      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 = {
+          ...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 = {
+          ...queryResultErrors.fullname,
+          disclose: {
+            expected: `${queryResult.fullname.disclose.result}`,
+            received: `${fullnamePassport ?? fullnameIDCard}`,
+            message: "Fullname does not match the disclosed fullname in query result"
+          }
+        };
+      }
+    }
+    if (queryResult.firstname) {
+      const firstnamePassport = disclosedDataPassport.firstName && disclosedDataPassport.firstName.length > 0 ? disclosedDataPassport.firstName : disclosedDataPassport.name;
+      const firstnameIDCard = disclosedDataIDCard.firstName && disclosedDataIDCard.firstName.length > 0 ? disclosedDataIDCard.firstName : disclosedDataIDCard.name;
+      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 = {
+          ...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 = {
+          ...queryResultErrors.firstname,
+          disclose: {
+            expected: `${queryResult.firstname.disclose.result}`,
+            received: `${firstnamePassport ?? firstnameIDCard}`,
+            message: "Firstname does not match the disclosed firstname in query result"
+          }
+        };
+      }
+    }
+    if (queryResult.lastname) {
+      const lastnamePassport = disclosedDataPassport.lastName && disclosedDataPassport.lastName.length > 0 ? disclosedDataPassport.lastName : disclosedDataPassport.name;
+      const lastnameIDCard = disclosedDataIDCard.lastName && disclosedDataIDCard.lastName.length > 0 ? disclosedDataIDCard.lastName : disclosedDataIDCard.name;
+      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 = {
+          ...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 = {
+          ...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 };
+  }
+  static checkAgePublicInputs(proof, queryResult) {
+    const queryResultErrors = {};
+    let isCorrect = true;
+    const currentTime = /* @__PURE__ */ new Date();
+    const today = new Date(
+      currentTime.getFullYear(),
+      currentTime.getMonth(),
+      currentTime.getDate(),
+      0,
+      0,
+      0,
+      0
+    );
+    const minAge = (0, import_utils.getMinAgeFromCommittedInputs)(
+      proof.committedInputs?.compare_age
+    );
+    const maxAge = (0, import_utils.getMaxAgeFromCommittedInputs)(
+      proof.committedInputs?.compare_age
+    );
+    if (queryResult.age) {
+      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 = {
+          ...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 = {
+          ...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 = {
+            ...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.lte && !queryResult.age.eq && !queryResult.age.range && maxAge != 0) {
+        console.warn("Maximum age should be equal to 0");
+        isCorrect = false;
+        queryResultErrors.age = {
+          ...queryResultErrors.age,
+          disclose: {
+            expected: 0,
+            received: maxAge,
+            message: "Maximum age should be equal to 0"
+          }
+        };
+      }
+      if (!queryResult.age.gte && !queryResult.age.gt && !queryResult.age.eq && !queryResult.age.range && minAge != 0) {
+        console.warn("Minimum age should be equal to 0");
+        isCorrect = false;
+        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 = {
+          ...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 = {
+        ...queryResultErrors.age,
+        disclose: {
+          message: "Age is not set in the query result"
+        }
+      };
+    }
+    const currentDate = (0, import_utils.getCurrentDateFromCommittedInputs)(
+      proof.committedInputs?.compare_age
+    );
+    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 = {
+        ...queryResultErrors.age,
+        disclose: {
+          expected: `${today.toISOString()}`,
+          received: `${currentDate.toISOString()}`,
+          message: "Current date in the proof is too old"
+        }
+      };
+    }
+    return { isCorrect, queryResultErrors };
+  }
+  static checkBirthdatePublicInputs(proof, queryResult) {
+    const queryResultErrors = {};
+    let isCorrect = true;
+    const currentTime = /* @__PURE__ */ new Date();
+    const today = new Date(
+      currentTime.getFullYear(),
+      currentTime.getMonth(),
+      currentTime.getDate(),
+      0,
+      0,
+      0
+    );
+    const minDate = (0, import_utils.getBirthdateMinDateTimestamp)(
+      proof.committedInputs?.compare_birthdate,
+      -1 * import_utils.SECONDS_BETWEEN_1900_AND_1970
+    );
+    const maxDate = (0, import_utils.getBirthdateMaxDateTimestamp)(
+      proof.committedInputs?.compare_birthdate,
+      -1 * import_utils.SECONDS_BETWEEN_1900_AND_1970
+    );
+    const currentDate = (0, import_utils.getCurrentDateFromCommittedInputs)(
+      proof.committedInputs?.compare_birthdate
+    );
+    if (queryResult.birthdate) {
+      if (queryResult.birthdate.gte && queryResult.birthdate.gte.result && !(0, import_utils.areDatesEqual)(minDate, queryResult.birthdate.gte.expected)) {
+        console.warn("Birthdate is not greater than or equal to the expected birthdate");
+        isCorrect = false;
+        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 && !(0, import_utils.areDatesEqual)(maxDate, queryResult.birthdate.lte.expected)) {
+        console.warn("Birthdate is not less than the expected birthdate");
+        isCorrect = false;
+        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 && (!(0, import_utils.areDatesEqual)(minDate, queryResult.birthdate.range.expected[0]) || !(0, import_utils.areDatesEqual)(maxDate, queryResult.birthdate.range.expected[1]))) {
+          console.warn("Birthdate is not in the expected range");
+          isCorrect = false;
+          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.lt && !queryResult.birthdate.eq && !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 = {
+          ...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.gt && !queryResult.birthdate.eq && !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 = {
+          ...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 = {
+        ...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.birthdate = {
+        ...queryResultErrors.birthdate,
+        disclose: {
+          expected: `${today.toISOString()}`,
+          received: `${currentDate.toISOString()}`,
+          message: "Current date in the proof is too old"
+        }
+      };
+    }
+    return { isCorrect, queryResultErrors };
+  }
+  static checkExpiryDatePublicInputs(proof, queryResult) {
+    const queryResultErrors = {};
+    let isCorrect = true;
+    const currentTime = /* @__PURE__ */ new Date();
+    const today = new Date(
+      currentTime.getFullYear(),
+      currentTime.getMonth(),
+      currentTime.getDate(),
+      0,
+      0,
+      0
+    );
+    const minDate = (0, import_utils.getMinDateFromCommittedInputs)(
+      proof.committedInputs?.compare_expiry
+    );
+    const maxDate = (0, import_utils.getMaxDateFromCommittedInputs)(
+      proof.committedInputs?.compare_expiry
+    );
+    const currentDate = (0, import_utils.getCurrentDateFromCommittedInputs)(
+      proof.committedInputs?.compare_expiry
+    );
+    if (queryResult.expiry_date) {
+      if (queryResult.expiry_date.gte && queryResult.expiry_date.gte.result && !(0, import_utils.areDatesEqual)(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 = {
+          ...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 && !(0, import_utils.areDatesEqual)(maxDate, queryResult.expiry_date.lte.expected)) {
+        console.warn("Expiry date is not less than the expected expiry date");
+        isCorrect = false;
+        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 && (!(0, import_utils.areDatesEqual)(minDate, queryResult.expiry_date.range.expected[0]) || !(0, import_utils.areDatesEqual)(maxDate, queryResult.expiry_date.range.expected[1]))) {
+          console.warn("Expiry date is not in the expected range");
+          isCorrect = false;
+          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.lt && !queryResult.expiry_date.eq && !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 = {
+          ...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.gt && !queryResult.expiry_date.eq && !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 = {
+          ...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 = {
+        ...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.expiry_date = {
+        ...queryResultErrors.expiry_date,
+        disclose: {
+          expected: `${today.toISOString()}`,
+          received: `${currentDate.toISOString()}`,
+          message: "Current date in the proof is too old"
+        }
+      };
+    }
+    return { isCorrect, queryResultErrors };
+  }
+  static checkNationalityExclusionPublicInputs(queryResult, countryList) {
+    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 = {
+          ...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 = {
+        ...queryResultErrors.nationality,
+        out: {
+          message: "Nationality exclusion is not set in the query result"
+        }
+      };
+    }
+    for (let i = 1; i < countryList.length; i++) {
+      if (countryList[i] < countryList[i - 1]) {
+        console.warn(
+          "The nationality exclusion list has not been sorted, and thus the proof cannot be trusted"
+        );
+        isCorrect = false;
+        queryResultErrors.nationality = {
+          ...queryResultErrors.nationality,
+          out: {
+            message: "The nationality exclusion list has not been sorted, and thus the proof cannot be trusted"
+          }
+        };
+      }
+    }
+    return { isCorrect, queryResultErrors };
+  }
+  static checkIssuingCountryExclusionPublicInputs(queryResult, countryList) {
+    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 = {
+          ...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 = {
+        ...queryResultErrors.issuing_country,
+        out: {
+          message: "Issuing country exclusion is not set in the query result"
+        }
+      };
+    }
+    for (let i = 1; i < countryList.length; i++) {
+      if (countryList[i] < countryList[i - 1]) {
+        console.warn(
+          "The issuing country exclusion list has not been sorted, and thus the proof cannot be trusted"
+        );
+        isCorrect = false;
+        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 };
+  }
+  static checkNationalityInclusionPublicInputs(queryResult, countryList) {
+    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 = {
+          ...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 = {
+        ...queryResultErrors.nationality,
+        in: {
+          message: "Nationality inclusion is not set in the query result"
+        }
+      };
+    }
+    return { isCorrect, queryResultErrors };
+  }
+  static checkIssuingCountryInclusionPublicInputs(queryResult, countryList) {
+    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 = {
+          ...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 = {
+        ...queryResultErrors.issuing_country,
+        in: {
+          message: "Issuing country inclusion is not set in the query result"
+        }
+      };
+    }
+    return { isCorrect, queryResultErrors };
+  }
+  static checkScopeFromDisclosureProof(domain, proofData, queryResultErrors, key, scope) {
+    let isCorrect = true;
+    if (domain && (0, import_utils.getServiceScopeHash)(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)(domain).toString()}`,
+        received: `Scope: ${BigInt(proofData.publicInputs[1]).toString()}`,
+        message: "The proof comes from a different domain than the one expected"
+      };
+    }
+    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()}`,
+        message: "The proof uses a different scope than the one expected"
+      };
+    }
+    return { isCorrect, queryResultErrors };
+  }
+  static async checkCertificateRegistryRoot(root, queryResultErrors, outer) {
+    let isCorrect = true;
+    try {
+      const registryClient = new import_registry.RegistryClient({ chainId: 11155111 });
+      const isValid = await registryClient.isCertificateRootValid(root);
+      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}`,
+          message: "The ID was signed by an unrecognized root certificate"
+        };
+      }
+    } catch (error) {
+      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}`,
+        message: "The ID was signed by an unrecognized root certificate"
+      };
+    }
+    return { isCorrect, queryResultErrors };
+  }
+  static async checkCircuitRegistryRoot(root, queryResultErrors) {
+    let isCorrect = true;
+    try {
+      const registryClient = new import_registry.RegistryClient({ chainId: 11155111 });
+      const isValid = await registryClient.isCircuitRootValid(root);
+      if (!isValid) {
+        console.warn("The proof uses unrecognized circuits");
+        isCorrect = false;
+        queryResultErrors.outer.circuit = {
+          expected: `A valid circuit from ZKPassport Registry`,
+          received: `Got invalid circuit registry root: ${root}`,
+          message: "The proof uses an unrecognized circuit"
+        };
+      }
+    } catch (error) {
+      console.warn(error);
+      console.warn("The proof uses unrecognized circuits");
+      isCorrect = false;
+      queryResultErrors.outer.circuit = {
+        expected: `A valid circuit from ZKPassport Registry`,
+        received: `Got invalid circuit registry root: ${root}`,
+        message: "The proof uses an unrecognized circuit"
+      };
+    }
+    return { isCorrect, queryResultErrors };
+  }
+  static checkBindPublicInputs(queryResult, boundData) {
+    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 = {
+          ...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 = {
+          ...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 = {
+          ...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 };
+  }
+  static async checkSanctionsExclusionPublicInputs(queryResult, root, sanctionsBuilder) {
+    const queryResultErrors = {};
+    let isCorrect = true;
+    if (queryResult.sanctions && queryResult.sanctions.passed) {
+      const EXPECTED_ROOT = await sanctionsBuilder.getRoot();
+      if (root !== EXPECTED_ROOT) {
+        console.warn("Invalid sanctions registry root");
+        isCorrect = false;
+        queryResultErrors.sanctions = {
+          ...queryResultErrors.sanctions,
+          eq: {
+            expected: EXPECTED_ROOT,
+            received: root,
+            message: "Invalid sanctions registry root"
+          }
+        };
+      }
+    }
+    return { isCorrect, queryResultErrors };
+  }
+  static async checkFacematchPublicInputs(queryResult, facematchCommittedInputs) {
+    let isCorrect = true;
+    let queryResultErrors = {};
+    if (queryResult.facematch && queryResult.facematch.passed) {
+      if (facematchCommittedInputs.rootKeyLeaf !== APPLE_APP_ATTEST_ROOT_KEY_HASH) {
+        console.warn("Invalid facematch root key hash");
+        isCorrect = false;
+        queryResultErrors.facematch = {
+          ...queryResultErrors.facematch,
+          eq: {
+            expected: APPLE_APP_ATTEST_ROOT_KEY_HASH,
+            received: facematchCommittedInputs.rootKeyLeaf,
+            message: "Invalid facematch root key hash"
+          }
+        };
+      }
+      const EXPECTED_ENVIRONMENT = "production";
+      if (facematchCommittedInputs.environment !== EXPECTED_ENVIRONMENT) {
+        console.warn("Invalid facematch environment, it should be production");
+        isCorrect = false;
+        queryResultErrors.facematch = {
+          ...queryResultErrors.facematch,
+          eq: {
+            expected: EXPECTED_ENVIRONMENT,
+            received: facematchCommittedInputs.environment,
+            message: "Invalid facematch environment, it should be production"
+          }
+        };
+      }
+      if (facematchCommittedInputs.appId !== ZKPASSPORT_APP_ID_HASH) {
+        console.warn(
+          "Invalid facematch app id hash, the attestation should be coming from the ZKPassport app"
+        );
+        isCorrect = false;
+        queryResultErrors.facematch = {
+          ...queryResultErrors.facematch,
+          eq: {
+            expected: ZKPASSPORT_APP_ID_HASH,
+            received: facematchCommittedInputs.appId,
+            message: "Invalid facematch app id hash, the attestation should be coming from the ZKPassport app"
+          }
+        };
+      }
+    }
+    return { isCorrect, queryResultErrors };
+  }
+  static async checkPublicInputs(domain, proofs, queryResult, validity, scope) {
+    let commitmentIn;
+    let commitmentOut;
+    let isCorrect = true;
+    let uniqueIdentifier;
+    let uniqueIdentifierType;
+    const currentTime = /* @__PURE__ */ new Date();
+    const today = new Date(
+      currentTime.getFullYear(),
+      currentTime.getMonth(),
+      currentTime.getDate(),
+      0,
+      0,
+      0,
+      0
+    );
+    let queryResultErrors = {};
+    const sortedProofs = proofs.sort((a, b) => {
+      const proofOrder = [
+        "sig_check_dsc",
+        "sig_check_id_data",
+        "data_check_integrity",
+        "disclose_bytes",
+        "compare_age",
+        "compare_birthdate",
+        "compare_expiry",
+        "exclusion_check_nationality",
+        "inclusion_check_nationality",
+        "exclusion_check_issuing_country",
+        "inclusion_check_issuing_country",
+        "bind",
+        "exclusion_check_sanctions",
+        "facematch"
+      ];
+      const getIndex = (proof) => {
+        const name = proof.name || "";
+        return proofOrder.findIndex((p) => name.startsWith(p));
+      };
+      return getIndex(a) - getIndex(b);
+    });
+    for (const proof of sortedProofs) {
+      const proofData = (0, import_utils.getProofData)(proof.proof, (0, import_utils.getNumberOfPublicInputs)(proof.name));
+      if (proof.name?.startsWith("outer")) {
+        const isForEVM = proof.name?.startsWith("outer_evm");
+        const certificateRegistryRoot = (0, import_utils.getCertificateRegistryRootFromOuterProof)(proofData);
+        const {
+          isCorrect: isCorrectCertificateRegistryRoot,
+          queryResultErrors: queryResultErrorsCertificateRegistryRoot
+        } = await this.checkCertificateRegistryRoot(
+          certificateRegistryRoot.toString(16),
+          queryResultErrors,
+          true
+        );
+        isCorrect = isCorrect && isCorrectCertificateRegistryRoot;
+        queryResultErrors = {
+          ...queryResultErrors,
+          ...queryResultErrorsCertificateRegistryRoot
+        };
+        const circuitRegistryRoot = (0, import_utils.getCircuitRegistryRootFromOuterProof)(proofData);
+        const {
+          isCorrect: isCorrectCircuitRegistryRoot,
+          queryResultErrors: queryResultErrorsCircuitRegistryRoot
+        } = await this.checkCircuitRegistryRoot(circuitRegistryRoot.toString(16), queryResultErrors);
+        isCorrect = isCorrect && isCorrectCircuitRegistryRoot;
+        queryResultErrors = {
+          ...queryResultErrors,
+          ...queryResultErrorsCircuitRegistryRoot
+        };
+        const currentDate = (0, import_utils.getCurrentDateFromOuterProof)(proofData);
+        const todayToCurrentDate = today.getTime() - currentDate.getTime();
+        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 the validity period`
+          );
+          isCorrect = false;
+          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);
+        const committedInputs = proof.committedInputs;
+        const keysInCommittedInputs = Object.keys(committedInputs || {});
+        if (keysInCommittedInputs.length !== paramCommitments.length) {
+          console.warn("The proof does not verify all the requested conditions and information");
+          isCorrect = false;
+          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 (domain && (0, import_utils.getServiceScopeHash)(domain) !== (0, import_utils.getScopeFromOuterProof)(proofData)) {
+          console.warn("The proof comes from a different domain than the one expected");
+          isCorrect = false;
+          queryResultErrors.outer = {
+            ...queryResultErrors.outer,
+            scope: {
+              expected: `Scope: ${(0, import_utils.getServiceScopeHash)(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 = {
+            ...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.currentDateTimestamp,
+            ageCommittedInputs.minAge,
+            ageCommittedInputs.maxAge
+          ) : await (0, import_utils.getAgeParameterCommitment)(
+            ageCommittedInputs.currentDateTimestamp,
+            ageCommittedInputs.minAge,
+            ageCommittedInputs.maxAge
+          );
+          if (!paramCommitments.includes(ageParameterCommitment)) {
+            console.warn("This proof does not verify the age");
+            isCorrect = false;
+            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);
+          isCorrect = isCorrect && isCorrectAge;
+          queryResultErrors = {
+            ...queryResultErrors,
+            ...queryResultErrorsAge
+          };
+        } else if (!!committedInputs?.compare_birthdate) {
+          const birthdateCommittedInputs = committedInputs?.compare_birthdate;
+          const birthdateParameterCommitment = isForEVM ? await (0, import_utils.getDateEVMParameterCommitment)(
+            import_utils.ProofType.BIRTHDATE,
+            birthdateCommittedInputs.currentDateTimestamp,
+            birthdateCommittedInputs.minDateTimestamp,
+            birthdateCommittedInputs.maxDateTimestamp,
+            0
+          ) : await (0, import_utils.getDateParameterCommitment)(
+            import_utils.ProofType.BIRTHDATE,
+            birthdateCommittedInputs.currentDateTimestamp,
+            birthdateCommittedInputs.minDateTimestamp,
+            birthdateCommittedInputs.maxDateTimestamp,
+            0
+          );
+          if (!paramCommitments.includes(birthdateParameterCommitment)) {
+            console.warn("This proof does not verify the birthdate");
+            isCorrect = false;
+            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);
+          isCorrect = isCorrect && isCorrectBirthdate;
+          queryResultErrors = {
+            ...queryResultErrors,
+            ...queryResultErrorsBirthdate
+          };
+        } else if (!!committedInputs?.compare_expiry) {
+          const expiryCommittedInputs = committedInputs?.compare_expiry;
+          const expiryParameterCommitment = isForEVM ? await (0, import_utils.getDateEVMParameterCommitment)(
+            import_utils.ProofType.EXPIRY_DATE,
+            expiryCommittedInputs.currentDateTimestamp,
+            expiryCommittedInputs.minDateTimestamp,
+            expiryCommittedInputs.maxDateTimestamp
+          ) : await (0, import_utils.getDateParameterCommitment)(
+            import_utils.ProofType.EXPIRY_DATE,
+            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 = {
+              ...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);
+          isCorrect = isCorrect && isCorrectExpiryDate;
+          queryResultErrors = {
+            ...queryResultErrors,
+            ...queryResultErrorsExpiryDate
+          };
+        } else if (!!committedInputs?.disclose_bytes) {
+          const discloseCommittedInputs = committedInputs?.disclose_bytes;
+          const discloseParameterCommitment = isForEVM ? await (0, import_utils.getDiscloseEVMParameterCommitment)(
+            discloseCommittedInputs.discloseMask,
+            discloseCommittedInputs.disclosedBytes
+          ) : await (0, import_utils.getDiscloseParameterCommitment)(
+            discloseCommittedInputs.discloseMask,
+            discloseCommittedInputs.disclosedBytes
+          );
+          if (!paramCommitments.includes(discloseParameterCommitment)) {
+            console.warn("This proof does not verify any of the data disclosed");
+            isCorrect = false;
+            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);
+          isCorrect = isCorrect && isCorrectDisclose;
+          queryResultErrors = {
+            ...queryResultErrors,
+            ...queryResultErrorsDisclose
+          };
+        } else if (!!committedInputs?.inclusion_check_nationality) {
+          const inclusionCheckNationalityCommittedInputs = committedInputs?.inclusion_check_nationality;
+          const inclusionCheckNationalityParameterCommitment = isForEVM ? await (0, import_utils.getCountryEVMParameterCommitment)(
+            import_utils.ProofType.NATIONALITY_INCLUSION,
+            inclusionCheckNationalityCommittedInputs.countries
+          ) : await (0, import_utils.getCountryParameterCommitment)(
+            import_utils.ProofType.NATIONALITY_INCLUSION,
+            inclusionCheckNationalityCommittedInputs.countries
+          );
+          if (!paramCommitments.includes(inclusionCheckNationalityParameterCommitment)) {
+            console.warn("This proof does not verify the inclusion of the nationality");
+            isCorrect = false;
+            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;
+          const {
+            isCorrect: isCorrectNationalityInclusion,
+            queryResultErrors: queryResultErrorsNationalityInclusion
+          } = this.checkNationalityInclusionPublicInputs(queryResult, countryList);
+          isCorrect = isCorrect && isCorrectNationalityInclusion;
+          queryResultErrors = {
+            ...queryResultErrors,
+            ...queryResultErrorsNationalityInclusion
+          };
+        } else if (!!committedInputs?.inclusion_check_issuing_country) {
+          const inclusionCheckIssuingCountryCommittedInputs = committedInputs?.inclusion_check_issuing_country;
+          const inclusionCheckIssuingCountryParameterCommitment = isForEVM ? await (0, import_utils.getCountryEVMParameterCommitment)(
+            import_utils.ProofType.ISSUING_COUNTRY_INCLUSION,
+            inclusionCheckIssuingCountryCommittedInputs.countries
+          ) : await (0, import_utils.getCountryParameterCommitment)(
+            import_utils.ProofType.ISSUING_COUNTRY_INCLUSION,
+            inclusionCheckIssuingCountryCommittedInputs.countries
+          );
+          if (!paramCommitments.includes(inclusionCheckIssuingCountryParameterCommitment)) {
+            console.warn("This proof does not verify the inclusion of the issuing country");
+            isCorrect = false;
+            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;
+          const {
+            isCorrect: isCorrectIssuingCountryInclusion,
+            queryResultErrors: queryResultErrorsIssuingCountryInclusion
+          } = this.checkIssuingCountryInclusionPublicInputs(queryResult, countryList);
+          isCorrect = isCorrect && isCorrectIssuingCountryInclusion;
+          queryResultErrors = {
+            ...queryResultErrors,
+            ...queryResultErrorsIssuingCountryInclusion
+          };
+        } else if (!!committedInputs?.exclusion_check_nationality) {
+          const exclusionCheckNationalityCommittedInputs = committedInputs?.exclusion_check_nationality;
+          const exclusionCheckNationalityParameterCommitment = isForEVM ? await (0, import_utils.getCountryEVMParameterCommitment)(
+            import_utils.ProofType.NATIONALITY_EXCLUSION,
+            exclusionCheckNationalityCommittedInputs.countries
+          ) : await (0, import_utils.getCountryParameterCommitment)(
+            import_utils.ProofType.NATIONALITY_EXCLUSION,
+            exclusionCheckNationalityCommittedInputs.countries
+          );
+          if (!paramCommitments.includes(exclusionCheckNationalityParameterCommitment)) {
+            console.warn("This proof does not verify the exclusion of the nationality");
+            isCorrect = false;
+            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;
+          const {
+            isCorrect: isCorrectNationalityExclusion,
+            queryResultErrors: queryResultErrorsNationalityExclusion
+          } = this.checkNationalityExclusionPublicInputs(queryResult, countryList);
+          isCorrect = isCorrect && isCorrectNationalityExclusion;
+          queryResultErrors = {
+            ...queryResultErrors,
+            ...queryResultErrorsNationalityExclusion
+          };
+        } else if (!!committedInputs?.exclusion_check_issuing_country) {
+          const exclusionCheckIssuingCountryCommittedInputs = committedInputs?.exclusion_check_issuing_country;
+          const exclusionCheckIssuingCountryParameterCommitment = isForEVM ? await (0, import_utils.getCountryEVMParameterCommitment)(
+            import_utils.ProofType.ISSUING_COUNTRY_EXCLUSION,
+            exclusionCheckIssuingCountryCommittedInputs.countries
+          ) : await (0, import_utils.getCountryParameterCommitment)(
+            import_utils.ProofType.ISSUING_COUNTRY_EXCLUSION,
+            exclusionCheckIssuingCountryCommittedInputs.countries
+          );
+          if (!paramCommitments.includes(exclusionCheckIssuingCountryParameterCommitment)) {
+            console.warn("This proof does not verify the exclusion of the issuing country");
+            isCorrect = false;
+            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;
+          const {
+            isCorrect: isCorrectIssuingCountryExclusion,
+            queryResultErrors: queryResultErrorsIssuingCountryExclusion
+          } = this.checkIssuingCountryExclusionPublicInputs(queryResult, countryList);
+          isCorrect = isCorrect && isCorrectIssuingCountryExclusion;
+          queryResultErrors = {
+            ...queryResultErrors,
+            ...queryResultErrorsIssuingCountryExclusion
+          };
+        } else if (!!committedInputs?.bind) {
+          const bindCommittedInputs = committedInputs?.bind;
+          const bindParameterCommitment = isForEVM ? await (0, import_utils.getBindEVMParameterCommitment)((0, import_utils.formatBoundData)(bindCommittedInputs.data)) : await (0, import_utils.getBindParameterCommitment)((0, import_utils.formatBoundData)(bindCommittedInputs.data));
+          if (!paramCommitments.includes(bindParameterCommitment)) {
+            console.warn("This proof does not verify the bound data");
+            isCorrect = false;
+            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);
+          isCorrect = isCorrect && isCorrectBind;
+          queryResultErrors = {
+            ...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,
+            exclusionCheckSanctionsCommittedInputs.rootHash,
+            sanctionsBuilder
+          );
+          isCorrect = isCorrect && isCorrectSanctionsExclusion;
+          queryResultErrors = {
+            ...queryResultErrors,
+            ...queryResultErrorsSanctionsExclusion
+          };
+        } else if (!!committedInputs?.facematch) {
+          const facematchCommittedInputs = committedInputs?.facematch;
+          const facematchParameterCommitment = isForEVM ? await (0, import_utils.getFacematchEvmParameterCommitment)(
+            BigInt(facematchCommittedInputs.rootKeyLeaf),
+            facematchCommittedInputs.environment === "development" ? 0n : 1n,
+            BigInt(facematchCommittedInputs.appId),
+            // TODO: Uncomment this when the facematch mode is properly supported
+            // facematchCommittedInputs.mode === "regular" ? 1n : 2n,
+            1n
+          ) : await (0, import_utils.getFacematchParameterCommitment)(
+            BigInt(facematchCommittedInputs.rootKeyLeaf),
+            facematchCommittedInputs.environment === "development" ? 0n : 1n,
+            BigInt(facematchCommittedInputs.appId),
+            // TODO: Uncomment this when the facematch mode is properly supported
+            // facematchCommittedInputs.mode === "regular" ? 1n : 2n,
+            1n
+          );
+          if (!paramCommitments.includes(facematchParameterCommitment)) {
+            console.warn("This proof does not verify FaceMatch");
+            isCorrect = false;
+            queryResultErrors.facematch = {
+              ...queryResultErrors.facematch,
+              commitment: {
+                expected: `Facematch parameter commitment: ${facematchParameterCommitment.toString()}`,
+                received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
+                message: "This proof does not verify FaceMatch"
+              }
+            };
+          }
+          const { isCorrect: isCorrectFacematch, queryResultErrors: queryResultErrorsFacematch } = await this.checkFacematchPublicInputs(queryResult, facematchCommittedInputs);
+          isCorrect = isCorrect && isCorrectFacematch;
+          queryResultErrors = {
+            ...queryResultErrors,
+            ...queryResultErrorsFacematch
+          };
+        }
+        uniqueIdentifier = (0, import_utils.getNullifierFromOuterProof)(proofData).toString(10);
+        uniqueIdentifierType = (0, import_utils.getNullifierTypeFromOuterProof)(proofData);
+      } else if (proof.name?.startsWith("sig_check_dsc")) {
+        commitmentOut = (0, import_utils.getCommitmentFromDSCProof)(proofData);
+        const merkleRoot = (0, import_utils.getMerkleRootFromDSCProof)(proofData);
+        const {
+          isCorrect: isCorrectCertificateRegistryRoot,
+          queryResultErrors: queryResultErrorsCertificateRegistryRoot
+        } = await this.checkCertificateRegistryRoot(
+          merkleRoot.toString(16),
+          queryResultErrors,
+          false
+        );
+        isCorrect = isCorrect && isCorrectCertificateRegistryRoot;
+        queryResultErrors = {
+          ...queryResultErrors,
+          ...queryResultErrorsCertificateRegistryRoot
+        };
+      } else if (proof.name?.startsWith("sig_check_id_data")) {
+        commitmentIn = (0, import_utils.getCommitmentInFromIDDataProof)(proofData);
+        if (commitmentIn !== commitmentOut) {
+          console.warn(
+            "Failed to check the link between the certificate signature and ID signature"
+          );
+          isCorrect = false;
+          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);
+      } else if (proof.name?.startsWith("data_check_integrity")) {
+        commitmentIn = (0, import_utils.getCommitmentInFromIntegrityProof)(proofData);
+        if (commitmentIn !== commitmentOut) {
+          console.warn("Failed to check the link between the ID signature and the data signed");
+          isCorrect = false;
+          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 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 the validity period`
+          );
+          isCorrect = false;
+          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") {
+        commitmentIn = (0, import_utils.getCommitmentInFromDisclosureProof)(proofData);
+        if (commitmentIn !== commitmentOut) {
+          console.warn(
+            "Failed to check the link between the validity of the ID and the data to disclose"
+          );
+          isCorrect = false;
+          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);
+        const calculatedParamCommitment = await (0, import_utils.getDiscloseParameterCommitment)(
+          (proof.committedInputs?.disclose_bytes).discloseMask,
+          (proof.committedInputs?.disclose_bytes).disclosedBytes
+        );
+        if (paramCommitment !== calculatedParamCommitment) {
+          console.warn("The disclosed data does not match the data committed by the proof");
+          isCorrect = false;
+          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(
+          domain,
+          proofData,
+          queryResultErrors,
+          "disclose",
+          scope
+        );
+        isCorrect = isCorrect && isCorrectScope;
+        queryResultErrors = {
+          ...queryResultErrors,
+          ...queryResultErrorsScope
+        };
+        const { isCorrect: isCorrectDisclose, queryResultErrors: queryResultErrorsDisclose } = this.checkDiscloseBytesPublicInputs(proof, queryResult);
+        isCorrect = isCorrect && isCorrectDisclose && isCorrectScope;
+        queryResultErrors = {
+          ...queryResultErrors,
+          ...queryResultErrorsDisclose,
+          ...queryResultErrorsScope
+        };
+        uniqueIdentifier = (0, import_utils.getNullifierFromDisclosureProof)(proofData).toString(10);
+        uniqueIdentifierType = (0, import_utils.getNullifierTypeFromDisclosureProof)(proofData);
+      } else if (proof.name === "compare_age") {
+        commitmentIn = (0, import_utils.getCommitmentInFromDisclosureProof)(proofData);
+        if (commitmentIn !== commitmentOut) {
+          console.warn(
+            "Failed to check the link between the validity of the ID and the age derived from it"
+          );
+          isCorrect = false;
+          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.currentDateTimestamp,
+          committedInputs.minAge,
+          committedInputs.maxAge
+        );
+        if (paramCommitment !== calculatedParamCommitment) {
+          console.warn(
+            "The conditions for the age check do not match the conditions checked by the proof"
+          );
+          isCorrect = false;
+          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(domain, proofData, queryResultErrors, "age", scope);
+        const { isCorrect: isCorrectAge, queryResultErrors: queryResultErrorsAge } = this.checkAgePublicInputs(proof, queryResult);
+        isCorrect = isCorrect && isCorrectAge && isCorrectScope;
+        queryResultErrors = {
+          ...queryResultErrors,
+          ...queryResultErrorsAge,
+          ...queryResultErrorsScope
+        };
+        uniqueIdentifier = (0, import_utils.getNullifierFromDisclosureProof)(proofData).toString(10);
+        uniqueIdentifierType = (0, import_utils.getNullifierTypeFromDisclosureProof)(proofData);
+      } else if (proof.name === "compare_birthdate") {
+        commitmentIn = (0, import_utils.getCommitmentInFromDisclosureProof)(proofData);
+        if (commitmentIn !== commitmentOut) {
+          console.warn(
+            "Failed to check the link between the validity of the ID and the birthdate derived from it"
+          );
+          isCorrect = false;
+          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.currentDateTimestamp,
+          committedInputs.minDateTimestamp,
+          committedInputs.maxDateTimestamp,
+          0
+        );
+        if (paramCommitment !== calculatedParamCommitment) {
+          console.warn(
+            "The conditions for the birthdate check do not match the conditions checked by the proof"
+          );
+          isCorrect = false;
+          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(
+          domain,
+          proofData,
+          queryResultErrors,
+          "birthdate",
+          scope
+        );
+        const { isCorrect: isCorrectBirthdate, queryResultErrors: queryResultErrorsBirthdate } = this.checkBirthdatePublicInputs(proof, queryResult);
+        isCorrect = isCorrect && isCorrectBirthdate && isCorrectScope;
+        queryResultErrors = {
+          ...queryResultErrors,
+          ...queryResultErrorsBirthdate,
+          ...queryResultErrorsScope
+        };
+        uniqueIdentifier = (0, import_utils.getNullifierFromDisclosureProof)(proofData).toString(10);
+        uniqueIdentifierType = (0, import_utils.getNullifierTypeFromDisclosureProof)(proofData);
+      } else if (proof.name === "compare_expiry") {
+        commitmentIn = (0, import_utils.getCommitmentInFromDisclosureProof)(proofData);
+        if (commitmentIn !== commitmentOut) {
+          console.warn(
+            "Failed to check the link between the validity of the ID and its expiry date"
+          );
+          isCorrect = false;
+          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.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 = {
+            ...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(
+          domain,
+          proofData,
+          queryResultErrors,
+          "expiry_date",
+          scope
+        );
+        const { isCorrect: isCorrectExpiryDate, queryResultErrors: queryResultErrorsExpiryDate } = this.checkExpiryDatePublicInputs(proof, queryResult);
+        isCorrect = isCorrect && isCorrectExpiryDate && isCorrectScope;
+        queryResultErrors = {
+          ...queryResultErrors,
+          ...queryResultErrorsExpiryDate,
+          ...queryResultErrorsScope
+        };
+        uniqueIdentifier = (0, import_utils.getNullifierFromDisclosureProof)(proofData).toString(10);
+        uniqueIdentifierType = (0, import_utils.getNullifierTypeFromDisclosureProof)(proofData);
+      } else if (proof.name === "exclusion_check_nationality") {
+        commitmentIn = (0, import_utils.getCommitmentInFromDisclosureProof)(proofData);
+        if (commitmentIn !== commitmentOut) {
+          console.warn(
+            "Failed to check the link between the validity of the ID and the nationality exclusion check"
+          );
+          isCorrect = false;
+          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;
+        const paramCommittment = (0, import_utils.getParameterCommitmentFromDisclosureProof)(proofData);
+        const calculatedParamCommitment = await (0, import_utils.getCountryParameterCommitment)(
+          import_utils.ProofType.NATIONALITY_EXCLUSION,
+          countryList,
+          true
+        );
+        if (paramCommittment !== calculatedParamCommitment) {
+          console.warn(
+            "The committed country list for the exclusion check does not match the one from the proof"
+          );
+          isCorrect = false;
+          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(
+          domain,
+          proofData,
+          queryResultErrors,
+          "nationality",
+          scope
+        );
+        const {
+          isCorrect: isCorrectNationalityExclusion,
+          queryResultErrors: queryResultErrorsNationalityExclusion
+        } = this.checkNationalityExclusionPublicInputs(queryResult, countryList);
+        isCorrect = isCorrect && isCorrectNationalityExclusion && isCorrectScope;
+        queryResultErrors = {
+          ...queryResultErrors,
+          ...queryResultErrorsNationalityExclusion,
+          ...queryResultErrorsScope
+        };
+        uniqueIdentifier = (0, import_utils.getNullifierFromDisclosureProof)(proofData).toString(10);
+        uniqueIdentifierType = (0, import_utils.getNullifierTypeFromDisclosureProof)(proofData);
+      } else if (proof.name === "exclusion_check_issuing_country") {
+        commitmentIn = (0, import_utils.getCommitmentInFromDisclosureProof)(proofData);
+        if (commitmentIn !== commitmentOut) {
+          console.warn(
+            "Failed to check the link between the validity of the ID and the issuing country exclusion check"
+          );
+          isCorrect = false;
+          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;
+        const paramCommittment = (0, import_utils.getParameterCommitmentFromDisclosureProof)(proofData);
+        const calculatedParamCommitment = await (0, import_utils.getCountryParameterCommitment)(
+          import_utils.ProofType.ISSUING_COUNTRY_EXCLUSION,
+          countryList,
+          true
+        );
+        if (paramCommittment !== calculatedParamCommitment) {
+          console.warn(
+            "The committed country list for the issuing country exclusion check does not match the one from the proof"
+          );
+          isCorrect = false;
+          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(
+          domain,
+          proofData,
+          queryResultErrors,
+          "nationality",
+          scope
+        );
+        const {
+          isCorrect: isCorrectIssuingCountryExclusion,
+          queryResultErrors: queryResultErrorsIssuingCountryExclusion
+        } = this.checkIssuingCountryExclusionPublicInputs(queryResult, countryList);
+        isCorrect = isCorrect && isCorrectIssuingCountryExclusion && isCorrectScope;
+        queryResultErrors = {
+          ...queryResultErrors,
+          ...queryResultErrorsIssuingCountryExclusion,
+          ...queryResultErrorsScope
+        };
+        uniqueIdentifier = (0, import_utils.getNullifierFromDisclosureProof)(proofData).toString(10);
+        uniqueIdentifierType = (0, import_utils.getNullifierTypeFromDisclosureProof)(proofData);
+      } else if (proof.name === "inclusion_check_nationality") {
+        commitmentIn = (0, import_utils.getCommitmentInFromDisclosureProof)(proofData);
+        if (commitmentIn !== commitmentOut) {
+          console.warn(
+            "Failed to check the link between the validity of the ID and the nationality inclusion check"
+          );
+          isCorrect = false;
+          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;
+        const paramCommittment = (0, import_utils.getParameterCommitmentFromDisclosureProof)(proofData);
+        const calculatedParamCommitment = await (0, import_utils.getCountryParameterCommitment)(
+          import_utils.ProofType.NATIONALITY_INCLUSION,
+          countryList,
+          false
+        );
+        if (paramCommittment !== calculatedParamCommitment) {
+          console.warn(
+            "The committed country list for the nationality inclusion check does not match the one from the proof"
+          );
+          isCorrect = false;
+          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(
+          domain,
+          proofData,
+          queryResultErrors,
+          "nationality",
+          scope
+        );
+        const {
+          isCorrect: isCorrectNationalityInclusion,
+          queryResultErrors: queryResultErrorsNationalityInclusion
+        } = this.checkNationalityInclusionPublicInputs(queryResult, countryList);
+        isCorrect = isCorrect && isCorrectNationalityInclusion && isCorrectScope;
+        queryResultErrors = {
+          ...queryResultErrors,
+          ...queryResultErrorsNationalityInclusion,
+          ...queryResultErrorsScope
+        };
+        uniqueIdentifier = (0, import_utils.getNullifierFromDisclosureProof)(proofData).toString(10);
+        uniqueIdentifierType = (0, import_utils.getNullifierTypeFromDisclosureProof)(proofData);
+      } else if (proof.name === "inclusion_check_issuing_country") {
+        commitmentIn = (0, import_utils.getCommitmentInFromDisclosureProof)(proofData);
+        if (commitmentIn !== commitmentOut) {
+          console.warn(
+            "Failed to check the link between the validity of the ID and the issuing country inclusion check"
+          );
+          isCorrect = false;
+          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;
+        const paramCommittment = (0, import_utils.getParameterCommitmentFromDisclosureProof)(proofData);
+        const calculatedParamCommitment = await (0, import_utils.getCountryParameterCommitment)(
+          import_utils.ProofType.ISSUING_COUNTRY_INCLUSION,
+          countryList,
+          false
+        );
+        if (paramCommittment !== calculatedParamCommitment) {
+          console.warn(
+            "The committed country list for the issuing country inclusion check does not match the one from the proof"
+          );
+          isCorrect = false;
+          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(
+          domain,
+          proofData,
+          queryResultErrors,
+          "nationality",
+          scope
+        );
+        const {
+          isCorrect: isCorrectIssuingCountryInclusion,
+          queryResultErrors: queryResultErrorsIssuingCountryInclusion
+        } = this.checkIssuingCountryInclusionPublicInputs(queryResult, countryList);
+        isCorrect = isCorrect && isCorrectIssuingCountryInclusion && isCorrectScope;
+        queryResultErrors = {
+          ...queryResultErrors,
+          ...queryResultErrorsIssuingCountryInclusion,
+          ...queryResultErrorsScope
+        };
+        uniqueIdentifier = (0, import_utils.getNullifierFromDisclosureProof)(proofData).toString(10);
+        uniqueIdentifierType = (0, import_utils.getNullifierTypeFromDisclosureProof)(proofData);
+      } else if (proof.name === "bind") {
+        const bindCommittedInputs = proof.committedInputs?.bind;
+        const paramCommittment = (0, import_utils.getParameterCommitmentFromDisclosureProof)(proofData);
+        const calculatedParamCommitment = await (0, import_utils.getBindParameterCommitment)(
+          (0, import_utils.formatBoundData)(bindCommittedInputs.data)
+        );
+        if (paramCommittment !== calculatedParamCommitment) {
+          console.warn("The bound data does not match the one from the proof");
+          isCorrect = false;
+          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);
+        isCorrect = isCorrect && isCorrectBind;
+        queryResultErrors = {
+          ...queryResultErrors,
+          ...queryResultErrorsBind
+        };
+        uniqueIdentifier = (0, import_utils.getNullifierFromDisclosureProof)(proofData).toString(10);
+        uniqueIdentifierType = (0, import_utils.getNullifierTypeFromDisclosureProof)(proofData);
+      } 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,
+          exclusionCheckSanctionsCommittedInputs.rootHash,
+          sanctionsBuilder
+        );
+        isCorrect = isCorrect && isCorrectSanctionsExclusion;
+        queryResultErrors = {
+          ...queryResultErrors,
+          ...queryResultErrorsSanctionsExclusion
+        };
+        uniqueIdentifier = (0, import_utils.getNullifierFromDisclosureProof)(proofData).toString(10);
+        uniqueIdentifierType = (0, import_utils.getNullifierTypeFromDisclosureProof)(proofData);
+      } else if (proof.name === "facematch") {
+        const facematchCommittedInputs = proof.committedInputs?.facematch;
+        const paramCommittment = (0, import_utils.getParameterCommitmentFromDisclosureProof)(proofData);
+        const calculatedParamCommitment = await (0, import_utils.getFacematchParameterCommitment)(
+          BigInt(facematchCommittedInputs.rootKeyLeaf),
+          facematchCommittedInputs.environment === "development" ? 0n : 1n,
+          BigInt(facematchCommittedInputs.appId),
+          // TODO: Uncomment this when the facematch mode is properly supported
+          // facematchCommittedInputs.mode === "regular" ? 1n : 2n,
+          1n
+        );
+        if (paramCommittment !== calculatedParamCommitment) {
+          console.warn("The FaceMatch verification does not match the ones from the proof");
+          isCorrect = false;
+          queryResultErrors.facematch = {
+            ...queryResultErrors.facematch,
+            commitment: {
+              expected: `Commitment: ${calculatedParamCommitment.toString()}`,
+              received: `Commitment: ${paramCommittment.toString()}`,
+              message: "The FaceMatch verification does not match the ones from the proof"
+            }
+          };
+        }
+        const { isCorrect: isCorrectFacematch, queryResultErrors: queryResultErrorsFacematch } = await this.checkFacematchPublicInputs(queryResult, facematchCommittedInputs);
+        isCorrect = isCorrect && isCorrectFacematch;
+        queryResultErrors = {
+          ...queryResultErrors,
+          ...queryResultErrorsFacematch
+        };
+        uniqueIdentifier = (0, import_utils.getNullifierFromDisclosureProof)(proofData).toString(10);
+        uniqueIdentifierType = (0, import_utils.getNullifierTypeFromDisclosureProof)(proofData);
+      }
+    }
+    return { isCorrect, uniqueIdentifier, uniqueIdentifierType, queryResultErrors };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PublicInputChecker
+});