@zkpassport/sdk 0.11.0-beta.2 → 0.12.0

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

@@ -1,2139 +0,0 @@
-"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_IOS_APP_ID_HASH = "0x1fa73686cf510f8f85757b0602de0dd72a13e68ae2092462be8b72662e7f179b";
-var ZKPASSPORT_ANDROID_APP_ID_HASH = "0x24d9929b248be7eeecaa98e105c034a50539610f3fdd4cb9c8983ef4100d615d";
-var APPLE_APP_ATTEST_ROOT_KEY_HASH = "0x2532418a107c5306fa8308c22255792cf77e4a290cbce8a840a642a3e591340b";
-var GOOGLE_APP_ATTEST_RSA_ROOT_KEY_HASH = "0x16700a2d9168a194fc85f237af5829b5a2be05b8ae8ac4879ada34cf54a9c211";
-
-// src/public-input-checker.ts
-var PublicInputChecker = class {
-  static checkDiscloseBytesPublicInputs(proof, queryResult) {
-    const queryResultErrors = {};
-    let isCorrect = true;
-    const disclosedBytes = (proof.committedInputs?.disclose_bytes).disclosedBytes ?? (proof.committedInputs?.disclose_bytes_evm).disclosedBytes;
-    const disclosedDataPassport = import_utils.DisclosedData.fromDisclosedBytes(disclosedBytes, "passport");
-    const disclosedDataIDCard = import_utils.DisclosedData.fromDisclosedBytes(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 ?? proof.committedInputs?.compare_age_evm
-    );
-    const maxAge = (0, import_utils.getMaxAgeFromCommittedInputs)(
-      proof.committedInputs?.compare_age ?? proof.committedInputs?.compare_age_evm
-    );
-    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"
-        }
-      };
-    }
-    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 ?? proof.committedInputs?.compare_birthdate_evm,
-      -1 * import_utils.SECONDS_BETWEEN_1900_AND_1970
-    );
-    const maxDate = (0, import_utils.getBirthdateMaxDateTimestamp)(
-      proof.committedInputs?.compare_birthdate ?? proof.committedInputs?.compare_birthdate_evm,
-      -1 * import_utils.SECONDS_BETWEEN_1900_AND_1970
-    );
-    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"
-        }
-      };
-    }
-    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 ?? proof.committedInputs?.compare_expiry_evm
-    );
-    const maxDate = (0, import_utils.getMaxDateFromCommittedInputs)(
-      proof.committedInputs?.compare_expiry ?? proof.committedInputs?.compare_expiry_evm
-    );
-    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"
-        }
-      };
-    }
-    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) !== (0, import_utils.getServiceScopeFromDisclosureProof)(proofData)) {
-      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) !== (0, import_utils.getServiceSubScopeFromDisclosureProof)(proofData)) {
-      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 && facematchCommittedInputs.rootKeyLeaf !== GOOGLE_APP_ATTEST_RSA_ROOT_KEY_HASH) {
-        console.warn("Invalid facematch root key hash");
-        isCorrect = false;
-        queryResultErrors.facematch = {
-          ...queryResultErrors.facematch,
-          eq: {
-            expected: `${APPLE_APP_ATTEST_ROOT_KEY_HASH} (iOS) or ${GOOGLE_APP_ATTEST_RSA_ROOT_KEY_HASH} (Android)`,
-            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.appIdHash !== ZKPASSPORT_IOS_APP_ID_HASH && facematchCommittedInputs.appIdHash !== ZKPASSPORT_ANDROID_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_IOS_APP_ID_HASH} (iOS) or ${ZKPASSPORT_ANDROID_APP_ID_HASH} (Android)`,
-            received: facematchCommittedInputs.appIdHash,
-            message: "Invalid facematch app id hash, the attestation should be coming from the ZKPassport app"
-          }
-        };
-      }
-    }
-    return { isCorrect, queryResultErrors };
-  }
-  static async checkCurrentDate(circuitName, proofData, validity, queryResultErrors) {
-    const currentTime = /* @__PURE__ */ new Date();
-    const today = new Date(
-      currentTime.getFullYear(),
-      currentTime.getMonth(),
-      currentTime.getDate(),
-      0,
-      0,
-      0,
-      0
-    );
-    const currentDate = (0, import_utils.getCurrentDateFromDisclosureProof)(proofData);
-    const todayToCurrentDate = today.getTime() - currentDate.getTime();
-    const expectedDifference = validity ? validity * 1e3 : DEFAULT_VALIDITY * 1e3;
-    const actualDifference = today.getTime() - (today.getTime() - expectedDifference);
-    let isCorrect = true;
-    if (todayToCurrentDate >= actualDifference) {
-      console.warn("The date used to check the validity of the ID falls out of the validity period");
-      isCorrect = false;
-      if (!queryResultErrors[circuitName]) {
-        queryResultErrors[circuitName] = {};
-      }
-      queryResultErrors[circuitName].date = {
-        expected: `Difference: ${validity} seconds`,
-        received: `Difference: ${Math.round(todayToCurrentDate / 1e3)} seconds`,
-        message: "The date used to check the validity of the ID falls out of the validity period"
-      };
-    }
-    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 || !!committedInputs?.compare_age_evm) {
-          const ageCommittedInputs = committedInputs?.compare_age ?? committedInputs?.compare_age_evm;
-          const ageParameterCommitment = isForEVM ? await (0, import_utils.getAgeEVMParameterCommitment)(
-            ageCommittedInputs.minAge,
-            ageCommittedInputs.maxAge
-          ) : await (0, import_utils.getAgeParameterCommitment)(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
-          };
-        }
-        if (!!committedInputs?.compare_birthdate || !!committedInputs?.compare_birthdate_evm) {
-          const birthdateCommittedInputs = committedInputs?.compare_birthdate ?? committedInputs?.compare_birthdate_evm;
-          const birthdateParameterCommitment = isForEVM ? await (0, import_utils.getDateEVMParameterCommitment)(
-            import_utils.ProofType.BIRTHDATE,
-            birthdateCommittedInputs.minDateTimestamp,
-            birthdateCommittedInputs.maxDateTimestamp
-          ) : await (0, import_utils.getDateParameterCommitment)(
-            import_utils.ProofType.BIRTHDATE,
-            birthdateCommittedInputs.minDateTimestamp,
-            birthdateCommittedInputs.maxDateTimestamp
-          );
-          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
-          };
-        }
-        if (!!committedInputs?.compare_expiry || !!committedInputs?.compare_expiry_evm) {
-          const expiryCommittedInputs = committedInputs?.compare_expiry ?? committedInputs?.compare_expiry_evm;
-          const expiryParameterCommitment = isForEVM ? await (0, import_utils.getDateEVMParameterCommitment)(
-            import_utils.ProofType.EXPIRY_DATE,
-            expiryCommittedInputs.minDateTimestamp,
-            expiryCommittedInputs.maxDateTimestamp
-          ) : await (0, import_utils.getDateParameterCommitment)(
-            import_utils.ProofType.EXPIRY_DATE,
-            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
-          };
-        }
-        if (!!committedInputs?.disclose_bytes || !!committedInputs?.disclose_bytes_evm) {
-          const discloseCommittedInputs = committedInputs?.disclose_bytes ?? committedInputs?.disclose_bytes_evm;
-          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
-          };
-        }
-        if (!!committedInputs?.inclusion_check_nationality || !!committedInputs?.inclusion_check_nationality_evm) {
-          const inclusionCheckNationalityCommittedInputs = committedInputs?.inclusion_check_nationality ?? committedInputs?.inclusion_check_nationality_evm;
-          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
-          };
-        }
-        if (!!committedInputs?.inclusion_check_issuing_country || !!committedInputs?.inclusion_check_issuing_country_evm) {
-          const inclusionCheckIssuingCountryCommittedInputs = committedInputs?.inclusion_check_issuing_country ?? committedInputs?.inclusion_check_issuing_country_evm;
-          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
-          };
-        }
-        if (!!committedInputs?.exclusion_check_nationality || !!committedInputs?.exclusion_check_nationality_evm) {
-          const exclusionCheckNationalityCommittedInputs = committedInputs?.exclusion_check_nationality ?? committedInputs?.exclusion_check_nationality_evm;
-          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
-          };
-        }
-        if (!!committedInputs?.exclusion_check_issuing_country || !!committedInputs?.exclusion_check_issuing_country_evm) {
-          const exclusionCheckIssuingCountryCommittedInputs = committedInputs?.exclusion_check_issuing_country ?? committedInputs?.exclusion_check_issuing_country_evm;
-          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
-          };
-        }
-        if (!!committedInputs?.bind || !!committedInputs?.bind_evm) {
-          const bindCommittedInputs = committedInputs?.bind ?? committedInputs?.bind_evm;
-          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
-          };
-        }
-        if (!!committedInputs?.exclusion_check_sanctions || !!committedInputs?.exclusion_check_sanctions_evm) {
-          const sanctionsBuilder = await import_utils.SanctionsBuilder.create();
-          const exclusionCheckSanctionsCommittedInputs = committedInputs?.exclusion_check_sanctions ?? committedInputs?.exclusion_check_sanctions_evm;
-          const exclusionCheckSanctionsParameterCommitment = isForEVM ? await sanctionsBuilder.getSanctionsEvmParameterCommitment(
-            exclusionCheckSanctionsCommittedInputs.isStrict
-          ) : await sanctionsBuilder.getSanctionsParameterCommitment(
-            exclusionCheckSanctionsCommittedInputs.isStrict
-          );
-          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
-          };
-        }
-        if (!!committedInputs?.facematch || !!committedInputs?.facematch_evm) {
-          const facematchCommittedInputs = committedInputs?.facematch ?? committedInputs?.facematch_evm;
-          const facematchParameterCommitment = isForEVM ? await (0, import_utils.getFacematchEvmParameterCommitment)(
-            BigInt(facematchCommittedInputs.rootKeyLeaf),
-            facematchCommittedInputs.environment === "development" ? 0n : 1n,
-            BigInt(facematchCommittedInputs.appIdHash),
-            facematchCommittedInputs.mode === "regular" ? 1n : 2n
-          ) : await (0, import_utils.getFacematchParameterCommitment)(
-            BigInt(facematchCommittedInputs.rootKeyLeaf),
-            facematchCommittedInputs.environment === "development" ? 0n : 1n,
-            BigInt(facematchCommittedInputs.appIdHash),
-            facematchCommittedInputs.mode === "regular" ? 1n : 2n
-          );
-          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);
-      } 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
-        };
-        const { isCorrect: isCorrectCurrentDate, queryResultErrors: queryResultErrorsCurrentDate } = await this.checkCurrentDate(
-          "disclose",
-          proofData,
-          validity ?? DEFAULT_VALIDITY,
-          queryResultErrors
-        );
-        isCorrect = isCorrect && isCorrectCurrentDate;
-        queryResultErrors = {
-          ...queryResultErrors,
-          ...queryResultErrorsCurrentDate
-        };
-        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.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
-        };
-        const { isCorrect: isCorrectCurrentDate, queryResultErrors: queryResultErrorsCurrentDate } = await this.checkCurrentDate(
-          "age",
-          proofData,
-          validity ?? DEFAULT_VALIDITY,
-          queryResultErrors
-        );
-        isCorrect = isCorrect && isCorrectCurrentDate;
-        queryResultErrors = {
-          ...queryResultErrors,
-          ...queryResultErrorsCurrentDate
-        };
-        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.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
-        };
-        const { isCorrect: isCorrectCurrentDate, queryResultErrors: queryResultErrorsCurrentDate } = await this.checkCurrentDate(
-          "birthdate",
-          proofData,
-          validity ?? DEFAULT_VALIDITY,
-          queryResultErrors
-        );
-        isCorrect = isCorrect && isCorrectCurrentDate;
-        queryResultErrors = {
-          ...queryResultErrors,
-          ...queryResultErrorsCurrentDate
-        };
-        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.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
-        };
-        const { isCorrect: isCorrectCurrentDate, queryResultErrors: queryResultErrorsCurrentDate } = await this.checkCurrentDate(
-          "expiry_date",
-          proofData,
-          validity ?? DEFAULT_VALIDITY,
-          queryResultErrors
-        );
-        isCorrect = isCorrect && isCorrectCurrentDate;
-        queryResultErrors = {
-          ...queryResultErrors,
-          ...queryResultErrorsCurrentDate
-        };
-        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
-        };
-        const { isCorrect: isCorrectCurrentDate, queryResultErrors: queryResultErrorsCurrentDate } = await this.checkCurrentDate(
-          "nationality",
-          proofData,
-          validity ?? DEFAULT_VALIDITY,
-          queryResultErrors
-        );
-        isCorrect = isCorrect && isCorrectCurrentDate;
-        queryResultErrors = {
-          ...queryResultErrors,
-          ...queryResultErrorsCurrentDate
-        };
-        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
-        };
-        const { isCorrect: isCorrectCurrentDate, queryResultErrors: queryResultErrorsCurrentDate } = await this.checkCurrentDate(
-          "issuing_country",
-          proofData,
-          validity ?? DEFAULT_VALIDITY,
-          queryResultErrors
-        );
-        isCorrect = isCorrect && isCorrectCurrentDate;
-        queryResultErrors = {
-          ...queryResultErrors,
-          ...queryResultErrorsCurrentDate
-        };
-        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
-        };
-        const { isCorrect: isCorrectCurrentDate, queryResultErrors: queryResultErrorsCurrentDate } = await this.checkCurrentDate(
-          "nationality",
-          proofData,
-          validity ?? DEFAULT_VALIDITY,
-          queryResultErrors
-        );
-        isCorrect = isCorrect && isCorrectCurrentDate;
-        queryResultErrors = {
-          ...queryResultErrors,
-          ...queryResultErrorsCurrentDate
-        };
-        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
-        };
-        const { isCorrect: isCorrectCurrentDate, queryResultErrors: queryResultErrorsCurrentDate } = await this.checkCurrentDate(
-          "issuing_country",
-          proofData,
-          validity ?? DEFAULT_VALIDITY,
-          queryResultErrors
-        );
-        isCorrect = isCorrect && isCorrectCurrentDate;
-        queryResultErrors = {
-          ...queryResultErrors,
-          ...queryResultErrorsCurrentDate
-        };
-        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
-        };
-        const { isCorrect: isCorrectCurrentDate, queryResultErrors: queryResultErrorsCurrentDate } = await this.checkCurrentDate(
-          "bind",
-          proofData,
-          validity ?? DEFAULT_VALIDITY,
-          queryResultErrors
-        );
-        isCorrect = isCorrect && isCorrectCurrentDate;
-        queryResultErrors = {
-          ...queryResultErrors,
-          ...queryResultErrorsCurrentDate
-        };
-        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(
-          exclusionCheckSanctionsCommittedInputs.isStrict
-        );
-        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
-        };
-        const { isCorrect: isCorrectCurrentDate, queryResultErrors: queryResultErrorsCurrentDate } = await this.checkCurrentDate(
-          "sanctions",
-          proofData,
-          validity ?? DEFAULT_VALIDITY,
-          queryResultErrors
-        );
-        isCorrect = isCorrect && isCorrectCurrentDate;
-        queryResultErrors = {
-          ...queryResultErrors,
-          ...queryResultErrorsCurrentDate
-        };
-        uniqueIdentifier = (0, import_utils.getNullifierFromDisclosureProof)(proofData).toString(10);
-        uniqueIdentifierType = (0, import_utils.getNullifierTypeFromDisclosureProof)(proofData);
-      } else if (proof.name?.startsWith("facematch") && !proof.name?.endsWith("_evm")) {
-        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.appIdHash),
-          facematchCommittedInputs.mode === "regular" ? 1n : 2n
-        );
-        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
-        };
-        const { isCorrect: isCorrectCurrentDate, queryResultErrors: queryResultErrorsCurrentDate } = await this.checkCurrentDate(
-          "facematch",
-          proofData,
-          validity ?? DEFAULT_VALIDITY,
-          queryResultErrors
-        );
-        isCorrect = isCorrect && isCorrectCurrentDate;
-        queryResultErrors = {
-          ...queryResultErrors,
-          ...queryResultErrorsCurrentDate
-        };
-        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
-});