@zkpassport/sdk 0.5.6 → 0.5.7-beta.1

package/dist/cjs/index.cjs

@@ -0,0 +1,3169 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ASEAN_COUNTRIES: () => import_utils4.ASEAN_COUNTRIES,
+  EEA_COUNTRIES: () => import_utils4.EEA_COUNTRIES,
+  EU_COUNTRIES: () => import_utils4.EU_COUNTRIES,
+  MERCOSUR_COUNTRIES: () => import_utils4.MERCOSUR_COUNTRIES,
+  SANCTIONED_COUNTRIES: () => import_utils4.SANCTIONED_COUNTRIES,
+  SCHENGEN_COUNTRIES: () => import_utils4.SCHENGEN_COUNTRIES,
+  ZKPassport: () => ZKPassport
+});
+module.exports = __toCommonJS(index_exports);
+var import_i18n_iso_countries = require("i18n-iso-countries");
+var import_utils = require("@zkpassport/utils");
+var import_utils2 = require("@noble/ciphers/utils");
+
+// src/logger.ts
+var noLogger = {
+  debug: (..._) => {
+  },
+  info: (..._) => {
+  },
+  warn: (..._) => {
+  },
+  error: (..._) => {
+  }
+};
+
+// src/index.ts
+var import_en = __toESM(require("i18n-iso-countries/langs/en.json"), 1);
+var import_buffer = require("buffer/");
+var import_sha2 = require("@noble/hashes/sha2");
+var import_utils3 = require("@noble/hashes/utils");
+
+// src/assets/abi/ZKPassportVerifier.json
+var ZKPassportVerifier_default = {
+  abi: [
+    {
+      type: "constructor",
+      inputs: [{ name: "_rootRegistry", type: "address", internalType: "address" }],
+      stateMutability: "nonpayable"
+    },
+    {
+      type: "function",
+      name: "CERTIFICATE_REGISTRY_ID",
+      inputs: [],
+      outputs: [{ name: "", type: "bytes32", internalType: "bytes32" }],
+      stateMutability: "view"
+    },
+    {
+      type: "function",
+      name: "CIRCUIT_REGISTRY_ID",
+      inputs: [],
+      outputs: [{ name: "", type: "bytes32", internalType: "bytes32" }],
+      stateMutability: "view"
+    },
+    {
+      type: "function",
+      name: "addCertificateRegistryRoot",
+      inputs: [
+        { name: "certificateRegistryRoot", type: "bytes32", internalType: "bytes32" }
+      ],
+      outputs: [],
+      stateMutability: "nonpayable"
+    },
+    {
+      type: "function",
+      name: "addVerifiers",
+      inputs: [
+        { name: "vkeyHashes", type: "bytes32[]", internalType: "bytes32[]" },
+        { name: "verifiers", type: "address[]", internalType: "address[]" }
+      ],
+      outputs: [],
+      stateMutability: "nonpayable"
+    },
+    {
+      type: "function",
+      name: "admin",
+      inputs: [],
+      outputs: [{ name: "", type: "address", internalType: "address" }],
+      stateMutability: "view"
+    },
+    {
+      type: "function",
+      name: "getAgeProofInputs",
+      inputs: [
+        { name: "committedInputs", type: "bytes", internalType: "bytes" },
+        { name: "committedInputCounts", type: "uint256[]", internalType: "uint256[]" }
+      ],
+      outputs: [
+        { name: "currentDate", type: "uint256", internalType: "uint256" },
+        { name: "minAge", type: "uint8", internalType: "uint8" },
+        { name: "maxAge", type: "uint8", internalType: "uint8" }
+      ],
+      stateMutability: "pure"
+    },
+    {
+      type: "function",
+      name: "getBindProofInputs",
+      inputs: [
+        { name: "committedInputs", type: "bytes", internalType: "bytes" },
+        { name: "committedInputCounts", type: "uint256[]", internalType: "uint256[]" }
+      ],
+      outputs: [{ name: "data", type: "bytes", internalType: "bytes" }],
+      stateMutability: "pure"
+    },
+    {
+      type: "function",
+      name: "getBoundData",
+      inputs: [{ name: "data", type: "bytes", internalType: "bytes" }],
+      outputs: [
+        { name: "senderAddress", type: "address", internalType: "address" },
+        { name: "customData", type: "string", internalType: "string" }
+      ],
+      stateMutability: "pure"
+    },
+    {
+      type: "function",
+      name: "getCountryProofInputs",
+      inputs: [
+        { name: "committedInputs", type: "bytes", internalType: "bytes" },
+        { name: "committedInputCounts", type: "uint256[]", internalType: "uint256[]" },
+        { name: "proofType", type: "uint8", internalType: "enum ProofType" }
+      ],
+      outputs: [{ name: "countryList", type: "string[]", internalType: "string[]" }],
+      stateMutability: "pure"
+    },
+    {
+      type: "function",
+      name: "getDateProofInputs",
+      inputs: [
+        { name: "committedInputs", type: "bytes", internalType: "bytes" },
+        { name: "committedInputCounts", type: "uint256[]", internalType: "uint256[]" },
+        { name: "proofType", type: "uint8", internalType: "enum ProofType" }
+      ],
+      outputs: [
+        { name: "currentDate", type: "uint256", internalType: "uint256" },
+        { name: "minDate", type: "uint256", internalType: "uint256" },
+        { name: "maxDate", type: "uint256", internalType: "uint256" }
+      ],
+      stateMutability: "pure"
+    },
+    {
+      type: "function",
+      name: "getDiscloseProofInputs",
+      inputs: [
+        { name: "committedInputs", type: "bytes", internalType: "bytes" },
+        { name: "committedInputCounts", type: "uint256[]", internalType: "uint256[]" }
+      ],
+      outputs: [
+        { name: "discloseMask", type: "bytes", internalType: "bytes" },
+        { name: "discloseBytes", type: "bytes", internalType: "bytes" }
+      ],
+      stateMutability: "pure"
+    },
+    {
+      type: "function",
+      name: "getDisclosedData",
+      inputs: [
+        { name: "discloseBytes", type: "bytes", internalType: "bytes" },
+        { name: "isIDCard", type: "bool", internalType: "bool" }
+      ],
+      outputs: [
+        { name: "name", type: "string", internalType: "string" },
+        { name: "issuingCountry", type: "string", internalType: "string" },
+        { name: "nationality", type: "string", internalType: "string" },
+        { name: "gender", type: "string", internalType: "string" },
+        { name: "birthDate", type: "string", internalType: "string" },
+        { name: "expiryDate", type: "string", internalType: "string" },
+        { name: "documentNumber", type: "string", internalType: "string" },
+        { name: "documentType", type: "string", internalType: "string" }
+      ],
+      stateMutability: "pure"
+    },
+    {
+      type: "function",
+      name: "isValidCertificateRegistryRoot",
+      inputs: [{ name: "", type: "bytes32", internalType: "bytes32" }],
+      outputs: [{ name: "", type: "bool", internalType: "bool" }],
+      stateMutability: "view"
+    },
+    {
+      type: "function",
+      name: "paused",
+      inputs: [],
+      outputs: [{ name: "", type: "bool", internalType: "bool" }],
+      stateMutability: "view"
+    },
+    {
+      type: "function",
+      name: "removeCertificateRegistryRoot",
+      inputs: [
+        { name: "certificateRegistryRoot", type: "bytes32", internalType: "bytes32" }
+      ],
+      outputs: [],
+      stateMutability: "nonpayable"
+    },
+    {
+      type: "function",
+      name: "removeVerifiers",
+      inputs: [{ name: "vkeyHashes", type: "bytes32[]", internalType: "bytes32[]" }],
+      outputs: [],
+      stateMutability: "nonpayable"
+    },
+    {
+      type: "function",
+      name: "rootRegistry",
+      inputs: [],
+      outputs: [{ name: "", type: "address", internalType: "contract IRootRegistry" }],
+      stateMutability: "view"
+    },
+    {
+      type: "function",
+      name: "setPaused",
+      inputs: [{ name: "_paused", type: "bool", internalType: "bool" }],
+      outputs: [],
+      stateMutability: "nonpayable"
+    },
+    {
+      type: "function",
+      name: "transferAdmin",
+      inputs: [{ name: "newAdmin", type: "address", internalType: "address" }],
+      outputs: [],
+      stateMutability: "nonpayable"
+    },
+    {
+      type: "function",
+      name: "updateRootRegistry",
+      inputs: [{ name: "_rootRegistry", type: "address", internalType: "address" }],
+      outputs: [],
+      stateMutability: "nonpayable"
+    },
+    {
+      type: "function",
+      name: "verifyProof",
+      inputs: [
+        {
+          name: "params",
+          type: "tuple",
+          internalType: "struct ProofVerificationParams",
+          components: [
+            { name: "vkeyHash", type: "bytes32", internalType: "bytes32" },
+            { name: "proof", type: "bytes", internalType: "bytes" },
+            { name: "publicInputs", type: "bytes32[]", internalType: "bytes32[]" },
+            { name: "committedInputs", type: "bytes", internalType: "bytes" },
+            { name: "committedInputCounts", type: "uint256[]", internalType: "uint256[]" },
+            { name: "validityPeriodInDays", type: "uint256", internalType: "uint256" },
+            { name: "domain", type: "string", internalType: "string" },
+            { name: "scope", type: "string", internalType: "string" },
+            { name: "devMode", type: "bool", internalType: "bool" }
+          ]
+        }
+      ],
+      outputs: [
+        { name: "", type: "bool", internalType: "bool" },
+        { name: "", type: "bytes32", internalType: "bytes32" }
+      ],
+      stateMutability: "view"
+    },
+    {
+      type: "function",
+      name: "verifyScopes",
+      inputs: [
+        { name: "publicInputs", type: "bytes32[]", internalType: "bytes32[]" },
+        { name: "domain", type: "string", internalType: "string" },
+        { name: "scope", type: "string", internalType: "string" }
+      ],
+      outputs: [{ name: "", type: "bool", internalType: "bool" }],
+      stateMutability: "view"
+    },
+    {
+      type: "function",
+      name: "vkeyHashToVerifier",
+      inputs: [{ name: "", type: "bytes32", internalType: "bytes32" }],
+      outputs: [{ name: "", type: "address", internalType: "address" }],
+      stateMutability: "view"
+    },
+    {
+      type: "event",
+      name: "AdminUpdated",
+      inputs: [
+        { name: "oldAdmin", type: "address", indexed: true, internalType: "address" },
+        { name: "newAdmin", type: "address", indexed: true, internalType: "address" }
+      ],
+      anonymous: false
+    },
+    {
+      type: "event",
+      name: "CertificateRegistryRootAdded",
+      inputs: [
+        {
+          name: "certificateRegistryRoot",
+          type: "bytes32",
+          indexed: true,
+          internalType: "bytes32"
+        }
+      ],
+      anonymous: false
+    },
+    {
+      type: "event",
+      name: "CertificateRegistryRootRemoved",
+      inputs: [
+        {
+          name: "certificateRegistryRoot",
+          type: "bytes32",
+          indexed: true,
+          internalType: "bytes32"
+        }
+      ],
+      anonymous: false
+    },
+    {
+      type: "event",
+      name: "PausedStatusChanged",
+      inputs: [{ name: "paused", type: "bool", indexed: false, internalType: "bool" }],
+      anonymous: false
+    },
+    {
+      type: "event",
+      name: "VerifierAdded",
+      inputs: [
+        { name: "vkeyHash", type: "bytes32", indexed: true, internalType: "bytes32" },
+        { name: "verifier", type: "address", indexed: true, internalType: "address" }
+      ],
+      anonymous: false
+    },
+    {
+      type: "event",
+      name: "VerifierRemoved",
+      inputs: [
+        { name: "vkeyHash", type: "bytes32", indexed: true, internalType: "bytes32" }
+      ],
+      anonymous: false
+    },
+    {
+      type: "event",
+      name: "ZKPassportVerifierDeployed",
+      inputs: [
+        { name: "admin", type: "address", indexed: true, internalType: "address" },
+        { name: "timestamp", type: "uint256", indexed: false, internalType: "uint256" }
+      ],
+      anonymous: false
+    }
+  ],
+  bytecode: {
+    object: "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",
+    sourceMap: "878:18823:27:-:0;;;4273:256;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;4322:27:27;;4314:76;;;;-1:-1:-1;;;4314:76:27;;511:2:31;4314:76:27;;;493:21:31;550:2;530:18;;;523:30;589:34;569:18;;;562:62;-1:-1:-1;;;640:18:31;;;633:34;684:19;;4314:76:27;;;;;;;;4396:5;:18;;4404:10;-1:-1:-1;;;;;;4396:18:27;;;;;;;;4420:12;:43;;;;;-1:-1:-1;;;;;4420:43:27;;;;;4474:50;;4508:15;860:25:31;;4474:50:27;;848:2:31;833:18;4474:50:27;;;;;;;4273:256;878:18823;;14:290:31;84:6;137:2;125:9;116:7;112:23;108:32;105:52;;;153:1;150;143:12;105:52;179:16;;-1:-1:-1;;;;;224:31:31;;214:42;;204:70;;270:1;267;260:12;204:70;293:5;14:290;-1:-1:-1;;;14:290:31:o;714:177::-;878:18823:27;;;;;;",
+    linkReferences: {}
+  },
+  deployedBytecode: {
+    object: "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",
+    sourceMap: "878:18823:27:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6785:2299;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;;;;;;;;14814:785;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;11721:1004::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;4952:118::-;;;;;;:::i;:::-;;:::i;:::-;;5603:206;;;;;;:::i;:::-;;:::i;5893:225::-;;;;;;:::i;:::-;;:::i;3244:69::-;;3310:1;3244:69;;;;;6486:25:31;;;6474:2;6459:18;3244:69:27;6340:177:31;3571:62:27;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;6687:14:31;;6680:22;6662:41;;6650:2;6635:18;3571:62:27;6522:187:31;12729:2081:27;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;3411:18::-;;;;;-1:-1:-1;;;3411:18:27;;;;;;3317:65;;3379:1;3317:65;;4719:229;;;;;;:::i;:::-;;:::i;3434:53::-;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;3434:53:27;;;;;;-1:-1:-1;;;;;7857:32:31;;;7839:51;;7827:2;7812:18;3434:53:27;7693:203:31;15603:791:27;;;;;;:::i;:::-;;:::i;6202:231::-;;;;;;:::i;:::-;;:::i;5368:::-;;;;;;:::i;:::-;;:::i;5074:290::-;;;;;;:::i;:::-;;:::i;10851:866::-;;;;;;:::i;:::-;;:::i;:::-;;;;10360:25:31;;;10433:4;10421:17;;;10416:2;10401:18;;10394:45;10475:17;;10455:18;;;10448:45;10348:2;10333:18;10851:866:27;10166:333:31;3708:33:27;;;;;-1:-1:-1;;;;;3708:33:27;;;18112:1587;;;;;;:::i;:::-;;:::i;:::-;;;;11337:14:31;;11330:22;11312:41;;11384:2;11369:18;;11362:34;;;;11285:18;18112:1587:27;11144:258:31;9088:822:27;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;9914:933::-;;;;;;:::i;:::-;;:::i;:::-;;;;12015:25:31;;;12071:2;12056:18;;12049:34;;;;12099:18;;;12092:34;12003:2;11988:18;9914:933:27;11813:319:31;3387:20:27;;;;;-1:-1:-1;;;;;3387:20:27;;;6785:2299;6908:18;6934:28;6970:25;7003:20;7031:23;7062:24;7094:28;7130:26;7176:8;7171:1909;;7208:13;2035:1;7208:13;7246:28;2035:1;7272:2;7246:28;:::i;:::-;7208:67;;;;;;;:::i;:::-;7194:82;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7194:82:27;;-1:-1:-1;7317:13:27;;-1:-1:-1;1026:1:27;;-1:-1:-1;7317:13:27;;-1:-1:-1;7358:30:27;1026:1;7387;7358:30;:::i;:::-;7317:72;;;;;;;:::i;:::-;7284:113;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7284:113:27;;-1:-1:-1;7435:13:27;;-1:-1:-1;1383:2:27;;-1:-1:-1;7435:13:27;;-1:-1:-1;7480:34:27;1383:2;7513:1;7480:34;:::i;:::-;7435:80;;;;;;;:::i;:::-;7405:118;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7405:118:27;;-1:-1:-1;7547:13:27;;-1:-1:-1;1510:2:27;;-1:-1:-1;7547:13:27;;-1:-1:-1;7587:29:27;1510:2;7615:1;7587:29;:::i;:::-;7547:70;;;;;;;:::i;:::-;7531:87;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7531:87:27;;-1:-1:-1;7654:13:27;;-1:-1:-1;1732:2:27;;-1:-1:-1;7654:13:27;;-1:-1:-1;7697:32:27;1732:2;7728:1;7697:32;:::i;:::-;7654:76;;;;;;;:::i;:::-;7626:112;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7626:112:27;;-1:-1:-1;7775:13:27;;-1:-1:-1;1609:2:27;;-1:-1:-1;7775:13:27;;-1:-1:-1;7820:34:27;1609:2;7853:1;7820:34;:::i;:::-;7775:80;;;;;;;:::i;:::-;7746:117;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7746:117:27;;-1:-1:-1;7904:13:27;;-1:-1:-1;1838:2:27;;-1:-1:-1;7904:13:27;;-1:-1:-1;7953:38:27;1838:2;7990:1;7953:38;:::i;:::-;7904:88;;;;;;;:::i;:::-;7871:129;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7871:129:27;;-1:-1:-1;8039:13:27;;7871:129;-1:-1:-1;8039:13:27;;-1:-1:-1;8086:36:27;;-1:-1:-1;7871:129:27;8121:1;8086:36;:::i;:::-;8039:84;;;;;;;:::i;:::-;8008:123;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;8008:123:27;;-1:-1:-1;7171:1909:27;;-1:-1:-1;;;7171:1909:27;;8166:13;3156:2;8166:13;8203:27;3156:2;8228;8203:27;:::i;:::-;8166:65;;;;;;;:::i;:::-;8152:80;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;8152:80:27;;-1:-1:-1;8273:13:27;;-1:-1:-1;2222:1:27;;-1:-1:-1;8273:13:27;;-1:-1:-1;8313:29:27;2222:1;8341;8313:29;:::i;:::-;8273:70;;;;;;;:::i;:::-;8240:111;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;8240:111:27;;-1:-1:-1;8389:13:27;;-1:-1:-1;2511:2:27;;-1:-1:-1;8389:13:27;;-1:-1:-1;8433:33:27;2511:2;8465:1;8433:33;:::i;:::-;8389:78;;;;;;;:::i;:::-;8359:116;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;8359:116:27;;-1:-1:-1;8499:13:27;;-1:-1:-1;2637:2:27;;-1:-1:-1;8499:13:27;;-1:-1:-1;8538:28:27;2637:2;8565:1;8538:28;:::i;:::-;8499:68;;;;;;;:::i;:::-;8483:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;8483:85:27;;-1:-1:-1;8604:13:27;;-1:-1:-1;2857:2:27;;-1:-1:-1;8604:13:27;;-1:-1:-1;8646:31:27;2857:2;8676:1;8646:31;:::i;:::-;8604:74;;;;;;;:::i;:::-;8576:110;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;8576:110:27;;-1:-1:-1;8723:13:27;;-1:-1:-1;2735:2:27;;-1:-1:-1;8723:13:27;;-1:-1:-1;8767:33:27;2735:2;8799:1;8767:33;:::i;:::-;8723:78;;;;;;;:::i;:::-;8694:115;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;8694:115:27;;-1:-1:-1;8850:13:27;;-1:-1:-1;2962:1:27;;-1:-1:-1;8850:13:27;;-1:-1:-1;8898:37:27;2962:1;8934;8898:37;:::i;:::-;8850:86;;;;;;;:::i;:::-;8817:127;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;8817:127:27;;-1:-1:-1;8983:13:27;;8817:127;-1:-1:-1;8983:13:27;;-1:-1:-1;9029:35:27;;-1:-1:-1;8817:127:27;9063:1;9029:35;:::i;:::-;8983:82;;;;;;;:::i;:::-;8952:121;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;8952:121:27;;-1:-1:-1;;;;7171:1909:27;6785:2299;;;;;;;;;;;:::o;14814:785::-;14886:21;14909:24;14886:21;14965:630;14981:3;14972:6;:12;14965:630;;;-1:-1:-1;;;14998:4:27;;15003:6;14998:12;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;14998:63:27;;;14994:595;;15073:20;15110:4;;15115:10;:6;15124:1;15115:10;:::i;:::-;15110:27;15126:10;:6;15135:1;15126:10;:::i;:::-;15110:27;;;;;;;:::i;:::-;15103:35;;;:::i;:::-;15096:43;;;-1:-1:-1;15181:4:27;;15186:10;:6;15195:1;15186:10;:::i;:::-;15181:43;15197:26;;;:10;:6;15206:1;15197:10;:::i;:::-;:26;;;;:::i;:::-;15181:43;;;;;;;:::i;:::-;15173:52;;;:::i;:::-;15165:61;;;-1:-1:-1;15246:17:27;15250:13;15246:1;:17;:::i;:::-;:21;;15266:1;15246:21;:::i;:::-;15236:31;;;;;;:::i;:::-;;;15063:213;14965:630;;14994:595;-1:-1:-1;;;15286:4:27;;15291:6;15286:12;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;15286:62:27;;;15282:307;;15360:23;15400:4;;15405:10;:6;15414:1;15405:10;:::i;:::-;15400:27;15416:10;:6;15425:1;15416:10;:::i;:::-;15400:27;;;;;;;:::i;:::-;15393:35;;;:::i;:::-;15386:43;;;-1:-1:-1;15459:4:27;;15464:10;:6;15473:1;15464:10;:::i;:::-;15459:46;15475:29;;;:10;:6;15484:1;15475:10;:::i;:::-;:29;;;;:::i;:::-;15459:46;;;;;;;:::i;:::-;15439:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;15439:67:27;;-1:-1:-1;15526:20:27;;-1:-1:-1;15530:16:27;;-1:-1:-1;15526:1:27;;-1:-1:-1;15526:20:27;:::i;15282:307::-;14935:664;14814:785;;;;;:::o;11721:1004::-;11883:27;11918:14;;;11966:701;11986:31;;;11966:701;;;12165:20;;12186:1;12165:23;;;;;;;:::i;:::-;;;;;;;12192:3;12165:30;:85;;;;;12239:9;12233:16;;;;;;;;:::i;:::-;12226:24;;-1:-1:-1;;;;;12199:51:27;;:15;;12215:6;12199:23;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;12199:51:27;;;12165:85;12161:459;;;12276:17;;;12289:3;12276:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;12262:31:27;-1:-1:-1;12308:9:27;12303:287;12327:3;12323:1;:7;12303:287;;;12353:15;;12378:5;:1;12382;12378:5;:::i;:::-;12369:14;;:6;:14;:::i;:::-;:18;;12386:1;12369:18;:::i;:::-;12353:35;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;;12353:35:27;12349:136;;-1:-1:-1;12467:5:27;12349:136;12520:15;;12545:5;:1;12549;12545:5;:::i;:::-;12536:14;;:6;:14;:::i;:::-;:18;;12553:1;12536:18;:::i;:::-;12520:58;12564:5;:1;12568;12564:5;:::i;:::-;12555:14;;:6;:14;:::i;:::-;:18;;12572:1;12555:18;:::i;:::-;:22;;12576:1;12555:22;:::i;:::-;12520:58;;;;;;;:::i;:::-;12496:83;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;12496:14:27;;:11;;-1:-1:-1;12508:1:27;;-1:-1:-1;12496:14:27;;;;;;:::i;:::-;;;;;;;;;;:83;12332:3;;12303:287;;;;12607:4;12599:12;;12161:459;12637:20;;12658:1;12637:23;;;;;;;:::i;:::-;;;;;;;12627:33;;;;;:::i;:::-;;-1:-1:-1;12019:3:27;;11966:701;;;;12680:5;12672:48;;;;-1:-1:-1;;;12672:48:27;;14373:2:31;12672:48:27;;;14355:21:31;14412:2;14392:18;;;14385:30;14451:32;14431:18;;;14424:60;14501:18;;12672:48:27;;;;;;;;;11912:813;;11721:1004;;;;;;;:::o;4952:118::-;4582:5;;-1:-1:-1;;;;;4582:5:27;4568:10;:19;4560:58;;;;-1:-1:-1;;;4560:58:27;;;;;;;:::i;:::-;5010:6:::1;:16:::0;;;::::1;;-1:-1:-1::0;;;5010:16:27::1;-1:-1:-1::0;;;;5010:16:27;;::::1;;::::0;;5037:28:::1;::::0;::::1;::::0;::::1;::::0;5019:7;6687:14:31;6680:22;6662:41;;6650:2;6635:18;;6522:187;5037:28:27::1;;;;;;;;4952:118:::0;:::o;5603:206::-;4582:5;;-1:-1:-1;;;;;4582:5:27;4568:10;:19;4560:58;;;;-1:-1:-1;;;4560:58:27;;;;;;;:::i;:::-;-1:-1:-1;;;;;5687:27:27;::::1;5679:76;;;::::0;-1:-1:-1;;;5679:76:27;;15087:2:31;5679:76:27::1;::::0;::::1;15069:21:31::0;15126:2;15106:18;;;15099:30;15165:34;15145:18;;;15138:62;-1:-1:-1;;;15216:18:31;;;15209:34;15260:19;;5679:76:27::1;14885:400:31::0;5679:76:27::1;5761:12;:43:::0;;-1:-1:-1;;;;;;5761:43:27::1;-1:-1:-1::0;;;;;5761:43:27;;;::::1;::::0;;;::::1;::::0;;5603:206::o;5893:225::-;4582:5;;-1:-1:-1;;;;;4582:5:27;4568:10;:19;4560:58;;;;-1:-1:-1;;;4560:58:27;;;;;;;:::i;:::-;5987:55:::1;::::0;;;:30:::1;:55;::::0;;;;;:62;;-1:-1:-1;;5987:62:27::1;6045:4;5987:62;::::0;;6060:53;6018:23;;6060:53:::1;::::0;::::1;5893:225:::0;:::o;12729:2081::-;12863:17;12888:14;;;12936:1814;12956:31;;;12936:1814;;;13113:20;;13134:1;13113:23;;;;;;;:::i;:::-;;;;;;;13140:3;13113:30;13109:1594;;-1:-1:-1;;;13163:15:27;;13179:6;13163:23;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;13163:56:27;;;13155:87;;;;-1:-1:-1;;;13155:87:27;;;;;;;:::i;:::-;13528:18;13560:792;13580:3;13567:10;:16;13560:792;;;-1:-1:-1;;;13614:15:27;;13643:10;13630;:6;13683:32;13630:10;:::i;:::-;:23;;;;:::i;:::-;13614:40;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;13614:103:27;;;13597:745;;13744:20;13796:15;;13825:10;13812;:6;13821:1;13812:10;:::i;:::-;:23;;;;:::i;:::-;:27;;13838:1;13812:27;:::i;:::-;13796:72;13853:10;13840;:6;13849:1;13840:10;:::i;:::-;:23;;;;:::i;:::-;:27;;13866:1;13840:27;:::i;:::-;13796:72;;;;;;;:::i;:::-;13789:80;;;:::i;:::-;13767:116;;;-1:-1:-1;13911:17:27;13767:116;13911:1;:17;:::i;:::-;:21;;13931:1;13911:21;:::i;:::-;13897:35;;;;;;:::i;:::-;;;13730:215;13560:792;;13597:745;-1:-1:-1;;;13968:15:27;;13997:10;13984;:6;13993:1;13984:10;:::i;:::-;:23;;;;:::i;:::-;13968:40;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;13968:102:27;;;13951:391;;14097:23;14152:15;;14181:10;14168;:6;14177:1;14168:10;:::i;13951:391::-;14382:1;14369:10;:14;:35;;;;;14401:3;14387:10;:17;;14369:35;14361:67;;;;-1:-1:-1;;;14361:67:27;;15839:2:31;14361:67:27;;;15821:21:31;15878:2;15858:18;;;15851:30;-1:-1:-1;;;15897:18:31;;;15890:49;15956:18;;14361:67:27;15637:343:31;14361:67:27;14502:10;14485:130;14518:3;14514:1;:7;14485:130;;;14548:15;;14577:1;14564:10;:6;14573:1;14564:10;:::i;:::-;:14;;;;:::i;:::-;14548:31;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;;14548:31:27;:36;;-1:-1:-1;14540:64:27;;;;-1:-1:-1;;;14540:64:27;;16187:2:31;14540:64:27;;;16169:21:31;16226:2;16206:18;;;16199:30;-1:-1:-1;;;16245:18:31;;;16238:45;16300:18;;14540:64:27;15985:339:31;14540:64:27;14523:3;;14485:130;;;-1:-1:-1;14632:15:27;;14648:10;:6;14657:1;14648:10;:::i;:::-;14632:40;14659:12;:6;14668:3;14659:12;:::i;:::-;14632:40;;;;;;;:::i;:::-;14625:47;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;14625:47:27;;-1:-1:-1;14690:4:27;;-1:-1:-1;;;;;13109:1594:27;14720:20;;14741:1;14720:23;;;;;;;:::i;:::-;;;;;;;14710:33;;;;;:::i;:::-;;-1:-1:-1;12989:3:27;;12936:1814;;;;14763:5;14755:50;;;;-1:-1:-1;;;14755:50:27;;16531:2:31;14755:50:27;;;16513:21:31;;;16550:18;;;16543:30;16609:34;16589:18;;;16582:62;16661:18;;14755:50:27;16329:356:31;14755:50:27;12882:1928;;12729:2081;;;;;;:::o;4719:229::-;4582:5;;-1:-1:-1;;;;;4582:5:27;4568:10;:19;4560:58;;;;-1:-1:-1;;;4560:58:27;;;;;;;:::i;:::-;-1:-1:-1;;;;;4793:22:27;::::1;4785:63;;;::::0;-1:-1:-1;;;4785:63:27;;16892:2:31;4785:63:27::1;::::0;::::1;16874:21:31::0;16931:2;16911:18;;;16904:30;16970;16950:18;;;16943:58;17018:18;;4785:63:27::1;16690:352:31::0;4785:63:27::1;4854:16;4873:5:::0;;-1:-1:-1;;;;;4884:16:27;;::::1;-1:-1:-1::0;;;;;;4884:16:27;::::1;::::0;::::1;::::0;;4911:32:::1;::::0;4873:5;;;::::1;::::0;;;4911:32:::1;::::0;4854:16;4911:32:::1;4779:169;4719:229:::0;:::o;15603:791::-;15742:4;15792:21;15816:35;15837:13;15816:20;:35::i;:::-;15792:59;;15966:17;15986:27;16006:6;;15986:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;15986:19:27;;-1:-1:-1;;;15986:27:27:i;:::-;:112;;16097:1;16041:52;16065:6;;16084:7;16048:44;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;16048:44:27;;;;;;;;;;16041:52;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:57;;15986:112;;;16030:1;15986:112;15966:132;;16198:20;16221:26;16241:5;;16221:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;16221:19:27;;-1:-1:-1;;;16221:26:27:i;:::-;:90;;16310:1;16275:31;16299:5;;16282:23;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;16282:23:27;;;;;;;;;;16275:31;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:36;;16221:90;;;16264:1;16221:90;16198:113;;16344:9;16324:12;;16337:2;16324:16;;;;;;;:::i;:::-;;;;;;;:29;:65;;;;;16377:12;16357;;16370:2;16357:16;;;;;;;:::i;:::-;;;;;;;:32;16324:65;16317:72;15603:791;-1:-1:-1;;;;;;;;;;15603:791:27:o;6202:231::-;4582:5;;-1:-1:-1;;;;;4582:5:27;4568:10;:19;4560:58;;;;-1:-1:-1;;;4560:58:27;;;;;;;:::i;:::-;6357:5:::1;6299:55:::0;;;:30:::1;:55;::::0;;;;;:63;;-1:-1:-1;;6299:63:27::1;::::0;;6373:55;6330:23;;6373:55:::1;::::0;::::1;6202:231:::0;:::o;5368:::-;4582:5;;-1:-1:-1;;;;;4582:5:27;4568:10;:19;4560:58;;;;-1:-1:-1;;;4560:58:27;;;;;;;:::i;:::-;5454:9:::1;5449:146;5469:21:::0;;::::1;5449:146;;;5512:18;:33;5531:10;;5542:1;5531:13;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;::::1;;5512:33:::0;;-1:-1:-1;5512:33:27;::::1;::::0;;;;;;-1:-1:-1;5512:33:27;5505:40;;-1:-1:-1;;;;;;5505:40:27::1;::::0;;5574:10;;5585:1;5574:13;;::::1;;;;;:::i;:::-;;;;;;;5558:30;;;;;;;;;;5492:3;;5449:146;;;;5368:231:::0;;:::o;5074:290::-;4582:5;;-1:-1:-1;;;;;4582:5:27;4568:10;:19;4560:58;;;;-1:-1:-1;;;4560:58:27;;;;;;;:::i;:::-;5199:9:::1;5194:166;5214:21:::0;;::::1;5194:166;;;5286:9;;5296:1;5286:12;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;5250:18;:33;5269:10;;5280:1;5269:13;;;;;;;:::i;:::-;;;;;;;5250:33;;;;;;;;;;;;:48;;;;;-1:-1:-1::0;;;;;5250:48:27::1;;;;;-1:-1:-1::0;;;;;5250:48:27::1;;;;;;5340:9;;5350:1;5340:12;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;5311:42:27::1;5325:10;;5336:1;5325:13;;;;;;;:::i;:::-;;;;;;;5311:42;;;;;;;;;;5237:3;;5194:166;;;;5074:290:::0;;;;:::o;10851:866::-;10984:19;;;;;;11087:576;11107:31;;;11087:576;;;11257:20;;11278:1;11257:23;;;;;;;:::i;:::-;;;;;;;11284:2;11257:29;11253:363;;-1:-1:-1;;;11306:15:27;;11322:6;11306:23;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;11306:55:27;;;11298:86;;;;-1:-1:-1;;;11298:86:27;;;;;;;:::i;:::-;11408:70;11439:15;;11455:10;:6;11464:1;11455:10;:::i;:::-;11439:38;11466:10;:6;11475:1;11466:10;:::i;:::-;11439:38;;;;;;;:::i;:::-;11408:70;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;11408:30:27;;-1:-1:-1;;;11408:70:27:i;:::-;11394:84;-1:-1:-1;11503:15:27;;11519:10;:6;11528:1;11519:10;:::i;:::-;11503:27;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;11556:15:27;;-1:-1:-1;11556:15:27;11572:11;:6;11581:2;11572:11;:::i;:::-;11556:28;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;11603:4:27;;-1:-1:-1;;11253:363:27;11633:20;;11654:1;11633:23;;;;;;;:::i;:::-;;;;;;;11623:33;;;;;:::i;:::-;;-1:-1:-1;11140:3:27;;11087:576;;;;11676:5;11668:44;;;;-1:-1:-1;;;11668:44:27;;18598:2:31;11668:44:27;;;18580:21:31;18637:2;18617:18;;;18610:30;18676:28;18656:18;;;18649:56;18722:18;;11668:44:27;18396:350:31;11668:44:27;11033:684;;10851:866;;;;;;;;:::o;18112:1587::-;18219:4;4674:6;;18219:4;;-1:-1:-1;;;4674:6:27;;;;4673:7;4665:38;;;;-1:-1:-1;;;4665:38:27;;18953:2:31;4665:38:27;;;18935:21:31;18992:2;18972:18;;;18965:30;-1:-1:-1;;;19011:18:31;;;19004:48;19069:18;;4665:38:27;18751:342:31;4665:38:27;18240:16:::1;18259:29;18272:15:::0;::::1;18259:12;:29::i;:::-;18240:48:::0;-1:-1:-1;18454:30:27::1;18516:2;18487:19;;::::0;::::1;:6:::0;:19:::1;:::i;:::-;:31;::::0;;-1:-1:-1;18487:31:27::1;:::i;:::-;18454:64:::0;-1:-1:-1;18567:48:27::1;18592:19;;::::0;::::1;:6:::0;:19:::1;:::i;:::-;18612:1;18592:22;;;;;;;:::i;:::-;;;;;;;18567:24;:48::i;:::-;18660:44;18681:19;;::::0;::::1;:6:::0;:19:::1;:::i;:::-;18701:1;18681:22;;;;;;;:::i;:::-;;;;;;;18660:20;:44::i;:::-;18762:59;18772:19;;::::0;::::1;:6:::0;:19:::1;:::i;:::-;18762:59;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;;;;18793:27:27::1;::::0;::::1;;18762:9;:59::i;:::-;18747:122;;;::::0;-1:-1:-1;;;18747:122:27;;19983:2:31;18747:122:27::1;::::0;::::1;19965:21:31::0;;;20002:18;;;19995:30;20061:34;20041:18;;;20034:62;20113:18;;18747:122:27::1;19781:356:31::0;18747:122:27::1;18919:62;18932:19;;::::0;::::1;:6:::0;:19:::1;:::i;:::-;18953:13;;::::0;::::1;:6:::0;:13:::1;:::i;:::-;18968:12;;::::0;::::1;:6:::0;:12:::1;:::i;18919:62::-;18911:89;;;::::0;-1:-1:-1;;;18911:89:27;;20871:2:31;18911:89:27::1;::::0;::::1;20853:21:31::0;20910:2;20890:18;;;20883:30;-1:-1:-1;;;20929:18:31;;;20922:44;20983:18;;18911:89:27::1;20669:338:31::0;18911:89:27::1;19068:207;19154:19;;::::0;::::1;:6:::0;:19:::1;:::i;:::-;19174:2;::::0;19177:26:::1;19202:1;19177:22:::0;:26:::1;:::i;:::-;19154:50;;;;;;;:::i;:::-;19068:207;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;19212:22:27::1;::::0;-1:-1:-1;;;19212:22:27::1;::::0;::::1;::::0;::::1;:::i;:::-;19242:27;;::::0;::::1;:6:::0;:27:::1;:::i;:::-;19068:207;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;19068:21:27::1;::::0;-1:-1:-1;;;19068:207:27:i:1;:::-;19473:1;19406:19;;::::0;::::1;:6:::0;:19:::1;:::i;:::-;19426:26;19451:1;19426:22:::0;:26:::1;:::i;:::-;19406:47;;;;;;;:::i;:::-;;;;;;;:70;;:88;;;-1:-1:-1::0;19480:14:27::1;::::0;;;::::1;::::0;::::1;;:::i;:::-;19391:159;;;::::0;-1:-1:-1;;;19391:159:27;;22650:2:31;19391:159:27::1;::::0;::::1;22632:21:31::0;22689:2;22669:18;;;22662:30;22728:34;22708:18;;;22701:62;-1:-1:-1;;;22779:18:31;;;22772:38;22827:19;;19391:159:27::1;22448:404:31::0;19391:159:27::1;-1:-1:-1::0;;;;;19572:26:27;::::1;;19599:12;;::::0;::::1;:6:::0;:12:::1;:::i;:::-;19613:19;;::::0;::::1;:6:::0;:19:::1;:::i;:::-;19572:61;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;19641:19;;::::0;::::1;:6:::0;:19:::1;:::i;:::-;19661:26;19686:1;19661:22:::0;:26:::1;:::i;:::-;19641:47;;;;;;;:::i;:::-;;;;;;;19557:137;;;;;;18112:1587:::0;;;:::o;9088:822::-;9226:25;;9287:14;;;9335:516;9355:31;;;9335:516;;;9509:20;;9530:1;9509:23;;;;;;;:::i;:::-;;;;;;;9536:3;9509:30;9505:299;;9599:18;9559:15;;9575:6;9559:23;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;9559:60:27;;;9551:91;;;;-1:-1:-1;;;9551:91:27;;;;;;;:::i;:::-;9667:15;;9683:10;:6;9692:1;9683:10;:::i;:::-;9667:39;9694:11;:6;9703:2;9694:11;:::i;:::-;9667:39;;;;;;;:::i;:::-;9652:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;9652:54:27;;-1:-1:-1;9732:15:27;;-1:-1:-1;9732:15:27;;-1:-1:-1;9748:11:27;;-1:-1:-1;9748:6:27;9757:2;9748:11;:::i;:::-;9732:41;9760:12;:6;9769:3;9760:12;:::i;:::-;9732:41;;;;;;;:::i;:::-;9716:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;9716:57:27;;-1:-1:-1;9791:4:27;;-1:-1:-1;;;;9505:299:27;9821:20;;9842:1;9821:23;;;;;;;:::i;:::-;;;;;;;9811:33;;;;;:::i;:::-;;-1:-1:-1;9388:3:27;;9335:516;;;;9864:5;9856:49;;;;-1:-1:-1;;;9856:49:27;;24085:2:31;9856:49:27;;;24067:21:31;24124:2;24104:18;;;24097:30;24163:33;24143:18;;;24136:61;24214:18;;9856:49:27;23883:355:31;9856:49:27;9281:629;;9088:822;;;;;;;:::o;9914:933::-;10073:19;;;;;;10182:610;10202:31;;;10182:610;;;10351:20;;10372:1;10351:23;;;;;;;:::i;:::-;;;;;;;10378:2;10351:29;:84;;;;;10424:9;10418:16;;;;;;;;:::i;:::-;10411:24;;-1:-1:-1;;;;;10384:51:27;;:15;;10400:6;10384:23;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;10384:51:27;;;10351:84;10347:398;;;10461:70;10492:15;;10508:10;:6;10517:1;10508:10;:::i;10461:70::-;10447:84;-1:-1:-1;10551:71:27;10582:15;;10598:10;:6;10607:1;10598:10;:::i;:::-;10582:39;10609:11;:6;10618:2;10609:11;:::i;10551:71::-;10541:81;-1:-1:-1;10642:72:27;10673:15;;10689:11;:6;10698:2;10689:11;:::i;:::-;10673:40;10701:11;:6;10710:2;10701:11;:::i;10642:72::-;10632:82;;10732:4;10724:12;;10347:398;10762:20;;10783:1;10762:23;;;;;;;:::i;:::-;;;;;;;10752:33;;;;;:::i;:::-;;-1:-1:-1;10235:3:27;;10182:610;;;;10805:5;10797:45;;;;-1:-1:-1;;;10797:45:27;;24445:2:31;10797:45:27;;;24427:21:31;24484:2;24464:18;;;24457:30;24523:29;24503:18;;;24496:57;24570:18;;10797:45:27;24243:351:31;10797:45:27;10128:719;;9914:933;;;;;;;;;:::o;841:616:26:-;897:13;948:5;957:1;948:10;944:41;;-1:-1:-1;;968:10:26;;;;;;;;;;;;-1:-1:-1;;;968:10:26;;;;;841:616::o;944:41::-;1059:5;1044:12;1090:59;1097:9;;1090:59;;1116:8;;;;:::i;:::-;;-1:-1:-1;1132:10:26;;-1:-1:-1;1140:2:26;1132:10;;:::i;:::-;;;1090:59;;;1209:19;1241:6;-1:-1:-1;;;;;1231:17:26;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1231:17:26;;1209:39;;1297:128;1304:10;;1297:128;;1324:11;1334:1;1324:11;;:::i;:::-;;-1:-1:-1;1386:10:26;1394:2;1386:5;:10;:::i;:::-;1373:24;;:2;:24;:::i;:::-;1360:39;;1343:6;1350;1343:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;1343:56:26;;;;;;;;-1:-1:-1;1407:11:26;1416:2;1407:11;;:::i;:::-;;;1297:128;;;1445:6;841:616;-1:-1:-1;;;;841:616:26:o;262:101::-;338:15;:20;;262:101::o;1965:1238:20:-;523:17;;;;;;;;;;;;-1:-1:-1;;;523:17:20;;;;;2056:15;;;;;;2037:7;;2056:49;;2052:78;;-1:-1:-1;2122:1:20;;1965:1238;-1:-1:-1;1965:1238:20:o;2052:78::-;2135:12;2291:26;2309:4;2314:1;2309:7;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;;2309:7:20;2291:17;:26::i;:::-;2245;2263:4;2268:1;2263:7;;;;;;;;:::i;2245:26::-;:37;;2280:2;2245:37;:::i;:::-;2198:26;2216:4;2221:1;2216:7;;;;;;;;:::i;2198:26::-;:38;;2233:3;2198:38;:::i;:::-;2150:26;2168:4;2173:1;2168:7;;;;;;;;:::i;2150:26::-;:39;;2185:4;2150:39;:::i;:::-;:86;;;;:::i;:::-;:132;;;;:::i;:::-;:167;;;;:::i;:::-;2135:182;;2323:13;2373:26;2391:4;2396:1;2391:7;;;;;;;;:::i;2373:26::-;2339;2357:4;2362:1;2357:7;;;;;;;;:::i;2339:26::-;:31;;2368:2;2339:31;:::i;:::-;:60;;;;:::i;:::-;2323:76;;2405:11;2453:26;2471:4;2476:1;2471:7;;;;;;;;:::i;2453:26::-;2419;2437:4;2442:1;2437:7;;;;;;;;:::i;2419:26::-;:31;;2448:2;2419:31;:::i;:::-;:60;;;;:::i;:::-;2405:74;;173:4;2493;:29;;2485:64;;;;-1:-1:-1;;;2485:64:20;;25315:2:31;2485:64:20;;;25297:21:31;25354:2;25334:18;;;25327:30;-1:-1:-1;;;25373:18:31;;;25366:52;25435:18;;2485:64:20;25113:346:31;2485:64:20;2572:1;2563:5;:10;;:25;;;;;2586:2;2577:5;:11;;2563:25;2555:51;;;;-1:-1:-1;;;2555:51:20;;25666:2:31;2555:51:20;;;25648:21:31;25705:2;25685:18;;;25678:30;-1:-1:-1;;;25724:18:31;;;25717:43;25777:18;;2555:51:20;25464:337:31;2555:51:20;2627:1;2620:3;:8;;:46;;;;;2639:27;2654:5;2661:4;2639:14;:27::i;:::-;2632:3;:34;;2620:46;2612:70;;;;-1:-1:-1;;;2612:70:20;;26008:2:31;2612:70:20;;;25990:21:31;26047:2;26027:18;;;26020:30;-1:-1:-1;;;26066:18:31;;;26059:41;26117:18;;2612:70:20;25806:335:31;2612:70:20;2727:17;173:4;2754:108;2798:4;2794:1;:8;2754:108;;;2830:13;2841:1;2830:10;:13::i;:::-;:25;;2852:3;2830:25;;;2846:3;2830:25;2817:38;;;;;;:::i;:::-;;-1:-1:-1;2804:3:20;;2754:108;;;-1:-1:-1;2924:1:20;2907:87;2931:5;2927:1;:9;2907:87;;;2964:23;2979:1;2982:4;2964:14;:23::i;:::-;2951:36;;;;:::i;:::-;;-1:-1:-1;2938:3:20;;2907:87;;;-1:-1:-1;3046:7:20;3052:1;3046:3;:7;:::i;:::-;3033:20;;;;:::i;:::-;;-1:-1:-1;3171:27:20;350:5;3033:20;3171:27;:::i;:::-;3164:34;1965:1238;-1:-1:-1;;;;;;1965:1238:20:o;17013:210:27:-;17076:7;17110:28;;;:18;:28;;;;;;-1:-1:-1;;;;;17110:28:27;;17144:53;;;;-1:-1:-1;;;17144:53:27;;26348:2:31;17144:53:27;;;26330:21:31;26387:2;26367:18;;;26360:30;-1:-1:-1;;;26406:18:31;;;26399:48;26464:18;;17144:53:27;26146:342:31;17144:53:27;17210:8;17013:210;-1:-1:-1;;17013:210:27:o;17227:394::-;17442:47;;;;:30;:47;;;;;;;;;:125;;-1:-1:-1;17501:12:27;;:66;;-1:-1:-1;;;17501:66:27;;:12;:66;;;26667:25:31;26708:18;;;26701:34;;;-1:-1:-1;;;;;17501:12:27;;;;:24;;26640:18:31;;17501:66:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;17306:310;;;;-1:-1:-1;;;17306:310:27;;26948:2:31;17306:310:27;;;26930:21:31;26987:2;26967:18;;;26960:30;27026:34;27006:18;;;26999:62;-1:-1:-1;;;27077:18:31;;;27070:31;27118:19;;17306:310:27;26746:397:31;17306:310:27;17227:394;:::o;17625:194::-;17711:12;;:58;;-1:-1:-1;;;17711:58:27;;3379:1;17711:58;;;26667:25:31;26708:18;;;26701:34;;;-1:-1:-1;;;;;17711:12:27;;;;:24;;26640:18:31;;17711:58:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;17696:118;;;;-1:-1:-1;;;17696:118:27;;27350:2:31;17696:118:27;;;27332:21:31;27389:2;27369:18;;;27362:30;27428:31;27408:18;;;27401:59;27477:18;;17696:118:27;27148:353:31;6437:344:27;6591:12;;;6601:1;6591:12;;;;;;;;;6552:4;;;;6591:12;;;;;;;;;;;-1:-1:-1;;6564:39:27;-1:-1:-1;6626:1:27;6609:99;6633:2;6629:1;:6;6609:99;;;6697:3;6678:12;6691:1;6678:15;;;;;;;;:::i;:::-;;;;;;;:22;;6650:11;6666:1;6662;:5;;;;:::i;:::-;6650:18;;;;;;;;:::i;:::-;;;;:51;-1:-1:-1;;;;;6650:51:27;;;;;;;;-1:-1:-1;6637:3:27;;6609:99;;;;6720:56;6742:11;6755:20;6720:21;:56::i;16398:611::-;16571:14;;16595:410;16619:20;:27;16615:1;:31;16595:410;;;16741:28;16874:1;16772:98;16805:15;;16821:6;16805:56;16837:20;16858:1;16837:23;;;;;;;;:::i;:::-;;;;;;;16828:6;:32;;;;:::i;:::-;16805:56;;;;;;;:::i;:::-;16788:74;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;16788:74:27;;;;;;;;;;16772:98;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:103;;16741:134;;16915:16;16932:1;16915:19;;;;;;;;:::i;:::-;;;;;;;16891:20;:43;16883:74;;;;-1:-1:-1;;;16883:74:27;;27990:2:31;16883:74:27;;;27972:21:31;28029:2;28009:18;;;28002:30;-1:-1:-1;;;28048:18:31;;;28041:48;28106:18;;16883:74:27;27788:342:31;16883:74:27;16975:20;16996:1;16975:23;;;;;;;;:::i;:::-;;;;;;;16965:33;;;;;:::i;:::-;;-1:-1:-1;;16648:3:27;;16595:410;;;;16565:444;16398:611;;;;:::o;704:116:20:-;772:7;794:21;813:2;794:16;;;;:21;:::i;:::-;787:28;;;704:116;-1:-1:-1;;704:116:20:o;1376:421::-;1452:7;1484:1;1475:5;:10;;:25;;;;;1498:2;1489:5;:11;;1475:25;1467:51;;;;-1:-1:-1;;;1467:51:20;;25666:2:31;1467:51:20;;;25648:21:31;25705:2;25685:18;;;25678:30;-1:-1:-1;;;25724:18:31;;;25717:43;25777:18;;1467:51:20;25464:337:31;1467:51:20;1573:5;1582:1;1573:10;1569:64;;1600:16;1611:4;1600:10;:16::i;:::-;:26;;1624:2;1600:26;;;1619:2;1600:26;1593:33;;;;;;1569:64;1671:5;1680:1;1671:10;:24;;;;1685:5;1694:1;1685:10;1671:24;:38;;;;1699:5;1708:1;1699:10;1671:38;:53;;;;1713:5;1722:2;1713:11;1671:53;1667:83;;;-1:-1:-1;1741:2:20;1734:9;;1667:83;-1:-1:-1;1790:2:20;1376:421;;;;:::o;975:199::-;1032:4;1048:8;1055:1;1048:4;:8;:::i;:::-;:13;1044:31;;-1:-1:-1;1070:5:20;;975:199;-1:-1:-1;975:199:20:o;1044:31::-;1085:10;1092:3;1085:4;:10;:::i;:::-;:15;1081:32;;-1:-1:-1;1109:4:20;;975:199;-1:-1:-1;975:199:20:o;1081:32::-;1123:10;1130:3;1123:4;:10;:::i;:::-;:15;1119:33;;-1:-1:-1;1147:5:20;;975:199;-1:-1:-1;975:199:20:o;1119:33::-;-1:-1:-1;1165:4:20;;975:199;-1:-1:-1;975:199:20:o;3465:401::-;3570:4;3582:17;3602:26;3623:4;3602:20;:26::i;:::-;3582:46;-1:-1:-1;3634:31:20;3680:38;350:5;3680:20;:38;:::i;:::-;3668:50;;:9;:50;:::i;:::-;3634:84;;3756:9;3737:15;:28;;:73;;;;;3801:9;3775:23;:35;3737:73;:124;;;;;3846:15;3820:23;:41;3737:124;3724:137;3465:401;-1:-1:-1;;;;;3465:401:20:o;14:347:31:-;65:8;75:6;129:3;122:4;114:6;110:17;106:27;96:55;;147:1;144;137:12;96:55;-1:-1:-1;170:20:31;;-1:-1:-1;;;;;202:30:31;;199:50;;;245:1;242;235:12;199:50;282:4;274:6;270:17;258:29;;334:3;327:4;318:6;310;306:19;302:30;299:39;296:59;;;351:1;348;341:12;296:59;14:347;;;;;:::o;366:118::-;452:5;445:13;438:21;431:5;428:32;418:60;;474:1;471;464:12;489:538;565:6;573;581;634:2;622:9;613:7;609:23;605:32;602:52;;;650:1;647;640:12;602:52;690:9;677:23;-1:-1:-1;;;;;715:6:31;712:30;709:50;;;755:1;752;745:12;709:50;794:58;844:7;835:6;824:9;820:22;794:58;:::i;:::-;871:8;;-1:-1:-1;768:84:31;-1:-1:-1;;956:2:31;941:18;;928:32;969:28;928:32;969:28;:::i;:::-;1016:5;1006:15;;;489:538;;;;;:::o;1032:300::-;1085:3;1123:5;1117:12;1150:6;1145:3;1138:19;1206:6;1199:4;1192:5;1188:16;1181:4;1176:3;1172:14;1166:47;1258:1;1251:4;1242:6;1237:3;1233:16;1229:27;1222:38;1321:4;1314:2;1310:7;1305:2;1297:6;1293:15;1289:29;1284:3;1280:39;1276:50;1269:57;;;1032:300;;;;:::o;1337:1455::-;1822:3;1811:9;1804:22;1785:4;1849:57;1901:3;1890:9;1886:19;1878:6;1849:57;:::i;:::-;1954:9;1946:6;1942:22;1937:2;1926:9;1922:18;1915:50;1988:44;2025:6;2017;1988:44;:::i;:::-;1974:58;;2080:9;2072:6;2068:22;2063:2;2052:9;2048:18;2041:50;2114:44;2151:6;2143;2114:44;:::i;:::-;2100:58;;2206:9;2198:6;2194:22;2189:2;2178:9;2174:18;2167:50;2240:44;2277:6;2269;2240:44;:::i;:::-;2226:58;;2333:9;2325:6;2321:22;2315:3;2304:9;2300:19;2293:51;2367:44;2404:6;2396;2367:44;:::i;:::-;2353:58;;2460:9;2452:6;2448:22;2442:3;2431:9;2427:19;2420:51;2494:44;2531:6;2523;2494:44;:::i;:::-;2480:58;;2587:9;2579:6;2575:22;2569:3;2558:9;2554:19;2547:51;2621:44;2658:6;2650;2621:44;:::i;:::-;2607:58;;2714:9;2706:6;2702:22;2696:3;2685:9;2681:19;2674:51;2742:44;2779:6;2771;2742:44;:::i;:::-;2734:52;1337:1455;-1:-1:-1;;;;;;;;;;;1337:1455:31:o;2797:409::-;2867:6;2875;2928:2;2916:9;2907:7;2903:23;2899:32;2896:52;;;2944:1;2941;2934:12;2896:52;2984:9;2971:23;-1:-1:-1;;;;;3009:6:31;3006:30;3003:50;;;3049:1;3046;3039:12;3003:50;3088:58;3138:7;3129:6;3118:9;3114:22;3088:58;:::i;:::-;3165:8;;3062:84;;-1:-1:-1;2797:409:31;-1:-1:-1;;;;2797:409:31:o;3211:328::-;-1:-1:-1;;;;;3388:32:31;;3370:51;;3457:2;3452;3437:18;;3430:30;;;-1:-1:-1;;3477:56:31;;3514:18;;3506:6;3477:56;:::i;3544:367::-;3607:8;3617:6;3671:3;3664:4;3656:6;3652:17;3648:27;3638:55;;3689:1;3686;3679:12;3638:55;-1:-1:-1;3712:20:31;;-1:-1:-1;;;;;3744:30:31;;3741:50;;;3787:1;3784;3777:12;3741:50;3824:4;3816:6;3812:17;3800:29;;3884:3;3877:4;3867:6;3864:1;3860:14;3852:6;3848:27;3844:38;3841:47;3838:67;;;3901:1;3898;3891:12;3916:899;4046:6;4054;4062;4070;4078;4131:2;4119:9;4110:7;4106:23;4102:32;4099:52;;;4147:1;4144;4137:12;4099:52;4187:9;4174:23;-1:-1:-1;;;;;4212:6:31;4209:30;4206:50;;;4252:1;4249;4242:12;4206:50;4291:58;4341:7;4332:6;4321:9;4317:22;4291:58;:::i;:::-;4368:8;;-1:-1:-1;4265:84:31;-1:-1:-1;;4456:2:31;4441:18;;4428:32;-1:-1:-1;;;;;4472:32:31;;4469:52;;;4517:1;4514;4507:12;4469:52;4556:72;4620:7;4609:8;4598:9;4594:24;4556:72;:::i;:::-;4647:8;;-1:-1:-1;4530:98:31;-1:-1:-1;;4732:2:31;4717:18;;4704:32;4765:1;4755:12;;4745:40;;4781:1;4778;4771:12;4745:40;4804:5;4794:15;;;3916:899;;;;;;;;:::o;4820:793::-;4982:4;5030:2;5019:9;5015:18;5060:2;5049:9;5042:21;5083:6;5118;5112:13;5149:6;5141;5134:22;5187:2;5176:9;5172:18;5165:25;;5249:2;5239:6;5236:1;5232:14;5221:9;5217:30;5213:39;5199:53;;5287:2;5279:6;5275:15;5308:1;5318:266;5332:6;5329:1;5326:13;5318:266;;;5425:2;5421:7;5409:9;5401:6;5397:22;5393:36;5388:3;5381:49;5453:51;5497:6;5488;5482:13;5453:51;:::i;:::-;5443:61;-1:-1:-1;5539:2:31;5562:12;;;;5527:15;;;;;5354:1;5347:9;5318:266;;;-1:-1:-1;5601:6:31;;4820:793;-1:-1:-1;;;;;;4820:793:31:o;5618:241::-;5674:6;5727:2;5715:9;5706:7;5702:23;5698:32;5695:52;;;5743:1;5740;5733:12;5695:52;5782:9;5769:23;5801:28;5823:5;5801:28;:::i;:::-;5848:5;5618:241;-1:-1:-1;;;5618:241:31:o;5864:286::-;5923:6;5976:2;5964:9;5955:7;5951:23;5947:32;5944:52;;;5992:1;5989;5982:12;5944:52;6018:23;;-1:-1:-1;;;;;6070:31:31;;6060:42;;6050:70;;6116:1;6113;6106:12;6155:180;6214:6;6267:2;6255:9;6246:7;6242:23;6238:32;6235:52;;;6283:1;6280;6273:12;6235:52;-1:-1:-1;6306:23:31;;6155:180;-1:-1:-1;6155:180:31:o;6714:740::-;6820:6;6828;6836;6844;6897:2;6885:9;6876:7;6872:23;6868:32;6865:52;;;6913:1;6910;6903:12;6865:52;6953:9;6940:23;-1:-1:-1;;;;;6978:6:31;6975:30;6972:50;;;7018:1;7015;7008:12;6972:50;7057:58;7107:7;7098:6;7087:9;7083:22;7057:58;:::i;:::-;7134:8;;-1:-1:-1;7031:84:31;-1:-1:-1;;7222:2:31;7207:18;;7194:32;-1:-1:-1;;;;;7238:32:31;;7235:52;;;7283:1;7280;7273:12;7235:52;7322:72;7386:7;7375:8;7364:9;7360:24;7322:72;:::i;:::-;6714:740;;;;-1:-1:-1;7413:8:31;-1:-1:-1;;;;6714:740:31:o;7459:229::-;7606:2;7595:9;7588:21;7569:4;7626:56;7678:2;7667:9;7663:18;7655:6;7626:56;:::i;7901:1045::-;8029:6;8037;8045;8053;8061;8069;8122:2;8110:9;8101:7;8097:23;8093:32;8090:52;;;8138:1;8135;8128:12;8090:52;8178:9;8165:23;-1:-1:-1;;;;;8203:6:31;8200:30;8197:50;;;8243:1;8240;8233:12;8197:50;8282:70;8344:7;8335:6;8324:9;8320:22;8282:70;:::i;:::-;8371:8;;-1:-1:-1;8256:96:31;-1:-1:-1;;8459:2:31;8444:18;;8431:32;-1:-1:-1;;;;;8475:32:31;;8472:52;;;8520:1;8517;8510:12;8472:52;8559:60;8611:7;8600:8;8589:9;8585:24;8559:60;:::i;:::-;8638:8;;-1:-1:-1;8533:86:31;-1:-1:-1;;8726:2:31;8711:18;;8698:32;-1:-1:-1;;;;;8742:32:31;;8739:52;;;8787:1;8784;8777:12;8739:52;8826:60;8878:7;8867:8;8856:9;8852:24;8826:60;:::i;:::-;7901:1045;;;;-1:-1:-1;7901:1045:31;;-1:-1:-1;7901:1045:31;;8905:8;;7901:1045;-1:-1:-1;;;7901:1045:31:o;8951:437::-;9037:6;9045;9098:2;9086:9;9077:7;9073:23;9069:32;9066:52;;;9114:1;9111;9104:12;9066:52;9154:9;9141:23;-1:-1:-1;;;;;9179:6:31;9176:30;9173:50;;;9219:1;9216;9209:12;9173:50;9258:70;9320:7;9311:6;9300:9;9296:22;9258:70;:::i;9393:768::-;9515:6;9523;9531;9539;9592:2;9580:9;9571:7;9567:23;9563:32;9560:52;;;9608:1;9605;9598:12;9560:52;9648:9;9635:23;-1:-1:-1;;;;;9673:6:31;9670:30;9667:50;;;9713:1;9710;9703:12;9667:50;9752:70;9814:7;9805:6;9794:9;9790:22;9752:70;:::i;10735:404::-;10838:6;10891:2;10879:9;10870:7;10866:23;10862:32;10859:52;;;10907:1;10904;10897:12;10859:52;10947:9;10934:23;-1:-1:-1;;;;;10972:6:31;10969:30;10966:50;;;11012:1;11009;11002:12;10966:50;11035:22;;11091:3;11073:16;;;11069:26;11066:46;;;11108:1;11105;11098:12;11407:401;11600:2;11589:9;11582:21;11563:4;11626:56;11678:2;11667:9;11663:18;11655:6;11626:56;:::i;:::-;11730:9;11722:6;11718:22;11713:2;11702:9;11698:18;11691:50;11758:44;11795:6;11787;11758:44;:::i;12137:127::-;12198:10;12193:3;12189:20;12186:1;12179:31;12229:4;12226:1;12219:15;12253:4;12250:1;12243:15;12269:125;12334:9;;;12355:10;;;12352:36;;;12368:18;;:::i;12399:331::-;12504:9;12515;12557:8;12545:10;12542:24;12539:44;;;12579:1;12576;12569:12;12539:44;12608:6;12598:8;12595:20;12592:40;;;12628:1;12625;12618:12;12592:40;-1:-1:-1;;12654:23:31;;;12699:25;;;;;-1:-1:-1;12399:331:31:o;12735:127::-;12796:10;12791:3;12787:20;12784:1;12777:31;12827:4;12824:1;12817:15;12851:4;12848:1;12841:15;12867:127;12928:10;12923:3;12919:20;12916:1;12909:31;12959:4;12956:1;12949:15;12983:4;12980:1;12973:15;12999:323;13119:19;;-1:-1:-1;;;;;;13156:24:31;;;13200:1;13192:10;;13189:127;;;-1:-1:-1;;;;;;13261:1:31;13257:11;;;13254:1;13250:19;13246:41;;;13238:50;;13234:72;;-1:-1:-1;13189:127:31;;12999:323;;;;:::o;13327:374::-;13448:19;;-1:-1:-1;;13485:40:31;;;13545:2;13537:11;;13534:161;;;-1:-1:-1;;13607:2:31;13603:12;;;;13600:1;13596:20;13592:58;;;13584:67;13580:105;;;;13327:374;-1:-1:-1;;13327:374:31:o;13706:155::-;13797:6;13774:14;;;13790;;;13770:35;;13817:15;;13814:41;;;13835:18;;:::i;13866:127::-;13927:10;13922:3;13918:20;13915:1;13908:31;13958:4;13955:1;13948:15;13982:4;13979:1;13972:15;13998:168;14071:9;;;14102;;14119:15;;;14113:22;;14099:37;14089:71;;14140:18;;:::i;14530:350::-;14732:2;14714:21;;;14771:2;14751:18;;;14744:30;14810:28;14805:2;14790:18;;14783:56;14871:2;14856:18;;14530:350::o;15290:342::-;15492:2;15474:21;;;15531:2;15511:18;;;15504:30;-1:-1:-1;;;15565:2:31;15550:18;;15543:48;15623:2;15608:18;;15290:342::o;17047:212::-;17089:3;17127:5;17121:12;17171:6;17164:4;17157:5;17153:16;17148:3;17142:36;17233:1;17197:16;;17222:13;;;-1:-1:-1;17197:16:31;;17047:212;-1:-1:-1;17047:212:31:o;17264:465::-;17598:6;17590;17585:3;17572:33;17554:3;17633:6;17628:3;17624:16;-1:-1:-1;;;17656:2:31;17649:21;17686:37;17720:1;17716:2;17712:10;17704:6;17686:37;:::i;17734:190::-;17863:3;17888:30;17914:3;17906:6;17888:30;:::i;17929:184::-;17999:6;18052:2;18040:9;18031:7;18027:23;18023:32;18020:52;;;18068:1;18065;18058:12;18020:52;-1:-1:-1;18091:16:31;;17929:184;-1:-1:-1;17929:184:31:o;18118:273::-;18303:6;18295;18290:3;18277:33;18259:3;18329:16;;18354:13;;;18329:16;18118:273;-1:-1:-1;18118:273:31:o;19098:545::-;19191:4;19197:6;19257:11;19244:25;19351:2;19347:7;19336:8;19320:14;19316:29;19312:43;19292:18;19288:68;19278:96;;19370:1;19367;19360:12;19278:96;19397:33;;19449:20;;;-1:-1:-1;;;;;;19481:30:31;;19478:50;;;19524:1;19521;19514:12;19478:50;19557:4;19545:17;;-1:-1:-1;19608:1:31;19604:14;;;19588;19584:35;19574:46;;19571:66;;;19633:1;19630;19623:12;19648:128;19715:9;;;19736:11;;;19733:37;;;19750:18;;:::i;20142:522::-;20220:4;20226:6;20286:11;20273:25;20380:2;20376:7;20365:8;20349:14;20345:29;20341:43;20321:18;20317:68;20307:96;;20399:1;20396;20389:12;20307:96;20426:33;;20478:20;;;-1:-1:-1;;;;;;20510:30:31;;20507:50;;;20553:1;20550;20543:12;20507:50;20586:4;20574:17;;-1:-1:-1;20617:14:31;20613:27;;;20603:38;;20600:58;;;20654:1;20651;20644:12;21012:355;21133:9;21144;21186:8;21174:10;21171:24;21168:44;;;21208:1;21205;21198:12;21168:44;21237:6;21227:8;21224:20;21221:40;;;21257:1;21254;21247:12;21221:40;-1:-1:-1;;21299:1:31;21295:18;;;21283:31;;21336:25;;;;;-1:-1:-1;21012:355:31:o;22857:771::-;23102:2;23091:9;23084:21;23141:6;23136:2;23125:9;23121:18;23114:34;23198:6;23190;23185:2;23174:9;23170:18;23157:48;23254:1;23249:2;23225:22;;;23221:31;;23214:42;;;-1:-1:-1;;23315:2:31;23294:15;;23290:29;23275:45;;23362:18;;;23358:27;;23351:4;23336:20;;23329:57;23402:11;;;23395:27;;;-1:-1:-1;;;;;23434:31:31;;23431:51;;;23478:1;23475;23468:12;23431:51;23512:6;23509:1;23505:14;23563:6;23555;23549:3;23545:2;23541:12;23528:42;23595:15;23587:35;;;;-1:-1:-1;;;;;;22857:771:31:o;23633:245::-;23700:6;23753:2;23741:9;23732:7;23728:23;23724:32;23721:52;;;23769:1;23766;23759:12;23721:52;23801:9;23795:16;23820:28;23842:5;23820:28;:::i;24599:135::-;24638:3;24659:17;;;24656:43;;24679:18;;:::i;:::-;-1:-1:-1;24726:1:31;24715:13;;24599:135::o;24739:127::-;24800:10;24795:3;24791:20;24788:1;24781:31;24831:4;24828:1;24821:15;24855:4;24852:1;24845:15;24871:120;24911:1;24937;24927:35;;24942:18;;:::i;:::-;-1:-1:-1;24976:9:31;;24871:120::o;24996:112::-;25028:1;25054;25044:35;;25059:18;;:::i;:::-;-1:-1:-1;25093:9:31;;24996:112::o;28135:151::-;28225:4;28218:12;;;28204;;;28200:31;;28243:14;;28240:40;;;28260:18;;:::i",
+    linkReferences: {}
+  },
+  methodIdentifiers: {
+    "CERTIFICATE_REGISTRY_ID()": "41a0e2c2",
+    "CIRCUIT_REGISTRY_ID()": "6c40d5d6",
+    "addCertificateRegistryRoot(bytes32)": "3a316e62",
+    "addVerifiers(bytes32[],address[])": "a6df2c01",
+    "admin()": "f851a440",
+    "getAgeProofInputs(bytes,uint256[])": "b2b37a4c",
+    "getBindProofInputs(bytes,uint256[])": "4601173c",
+    "getBoundData(bytes)": "0af18ba6",
+    "getCountryProofInputs(bytes,uint256[],uint8)": "126f7559",
+    "getDateProofInputs(bytes,uint256[],uint8)": "ec1374cd",
+    "getDiscloseProofInputs(bytes,uint256[])": "ddf3eec9",
+    "getDisclosedData(bytes,bool)": "03d37eae",
+    "isValidCertificateRegistryRoot(bytes32)": "45e21c90",
+    "paused()": "5c975abb",
+    "removeCertificateRegistryRoot(bytes32)": "886c3533",
+    "removeVerifiers(bytes32[])": "8d6937b8",
+    "rootRegistry()": "b96b161c",
+    "setPaused(bool)": "16c38b3c",
+    "transferAdmin(address)": "75829def",
+    "updateRootRegistry(address)": "18677f2a",
+    "verifyProof((bytes32,bytes,bytes32[],bytes,uint256[],uint256,string,string,bool))": "d7bf616a",
+    "verifyScopes(bytes32[],string,string)": "847755e3",
+    "vkeyHashToVerifier(bytes32)": "8163f231"
+  },
+  rawMetadata: '{"compiler":{"version":"0.8.29+commit.ab55807c"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"_rootRegistry","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldAdmin","type":"address"},{"indexed":true,"internalType":"address","name":"newAdmin","type":"address"}],"name":"AdminUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"certificateRegistryRoot","type":"bytes32"}],"name":"CertificateRegistryRootAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"certificateRegistryRoot","type":"bytes32"}],"name":"CertificateRegistryRootRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"paused","type":"bool"}],"name":"PausedStatusChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"vkeyHash","type":"bytes32"},{"indexed":true,"internalType":"address","name":"verifier","type":"address"}],"name":"VerifierAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"vkeyHash","type":"bytes32"}],"name":"VerifierRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"admin","type":"address"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"ZKPassportVerifierDeployed","type":"event"},{"inputs":[],"name":"CERTIFICATE_REGISTRY_ID","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"CIRCUIT_REGISTRY_ID","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"certificateRegistryRoot","type":"bytes32"}],"name":"addCertificateRegistryRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"vkeyHashes","type":"bytes32[]"},{"internalType":"address[]","name":"verifiers","type":"address[]"}],"name":"addVerifiers","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"admin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"committedInputs","type":"bytes"},{"internalType":"uint256[]","name":"committedInputCounts","type":"uint256[]"}],"name":"getAgeProofInputs","outputs":[{"internalType":"uint256","name":"currentDate","type":"uint256"},{"internalType":"uint8","name":"minAge","type":"uint8"},{"internalType":"uint8","name":"maxAge","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes","name":"committedInputs","type":"bytes"},{"internalType":"uint256[]","name":"committedInputCounts","type":"uint256[]"}],"name":"getBindProofInputs","outputs":[{"internalType":"bytes","name":"data","type":"bytes"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes","name":"data","type":"bytes"}],"name":"getBoundData","outputs":[{"internalType":"address","name":"senderAddress","type":"address"},{"internalType":"string","name":"customData","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes","name":"committedInputs","type":"bytes"},{"internalType":"uint256[]","name":"committedInputCounts","type":"uint256[]"},{"internalType":"enum ProofType","name":"proofType","type":"uint8"}],"name":"getCountryProofInputs","outputs":[{"internalType":"string[]","name":"countryList","type":"string[]"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes","name":"committedInputs","type":"bytes"},{"internalType":"uint256[]","name":"committedInputCounts","type":"uint256[]"},{"internalType":"enum ProofType","name":"proofType","type":"uint8"}],"name":"getDateProofInputs","outputs":[{"internalType":"uint256","name":"currentDate","type":"uint256"},{"internalType":"uint256","name":"minDate","type":"uint256"},{"internalType":"uint256","name":"maxDate","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes","name":"committedInputs","type":"bytes"},{"internalType":"uint256[]","name":"committedInputCounts","type":"uint256[]"}],"name":"getDiscloseProofInputs","outputs":[{"internalType":"bytes","name":"discloseMask","type":"bytes"},{"internalType":"bytes","name":"discloseBytes","type":"bytes"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes","name":"discloseBytes","type":"bytes"},{"internalType":"bool","name":"isIDCard","type":"bool"}],"name":"getDisclosedData","outputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"issuingCountry","type":"string"},{"internalType":"string","name":"nationality","type":"string"},{"internalType":"string","name":"gender","type":"string"},{"internalType":"string","name":"birthDate","type":"string"},{"internalType":"string","name":"expiryDate","type":"string"},{"internalType":"string","name":"documentNumber","type":"string"},{"internalType":"string","name":"documentType","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"isValidCertificateRegistryRoot","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"certificateRegistryRoot","type":"bytes32"}],"name":"removeCertificateRegistryRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"vkeyHashes","type":"bytes32[]"}],"name":"removeVerifiers","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rootRegistry","outputs":[{"internalType":"contract IRootRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"_paused","type":"bool"}],"name":"setPaused","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newAdmin","type":"address"}],"name":"transferAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_rootRegistry","type":"address"}],"name":"updateRootRegistry","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"bytes32","name":"vkeyHash","type":"bytes32"},{"internalType":"bytes","name":"proof","type":"bytes"},{"internalType":"bytes32[]","name":"publicInputs","type":"bytes32[]"},{"internalType":"bytes","name":"committedInputs","type":"bytes"},{"internalType":"uint256[]","name":"committedInputCounts","type":"uint256[]"},{"internalType":"uint256","name":"validityPeriodInDays","type":"uint256"},{"internalType":"string","name":"domain","type":"string"},{"internalType":"string","name":"scope","type":"string"},{"internalType":"bool","name":"devMode","type":"bool"}],"internalType":"struct ProofVerificationParams","name":"params","type":"tuple"}],"name":"verifyProof","outputs":[{"internalType":"bool","name":"","type":"bool"},{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"publicInputs","type":"bytes32[]"},{"internalType":"string","name":"domain","type":"string"},{"internalType":"string","name":"scope","type":"string"}],"name":"verifyScopes","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"vkeyHashToVerifier","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}],"devdoc":{"kind":"dev","methods":{"constructor":{"details":"Constructor"},"verifyProof((bytes32,bytes,bytes32[],bytes,uint256[],uint256,string,string,bool))":{"params":{"params":"The proof verification parameters"},"returns":{"_0":"isValid True if the proof is valid, false otherwise","_1":"uniqueIdentifier The unique identifier associated to the identity document that generated the proof"}}},"version":1},"userdoc":{"kind":"user","methods":{"verifyProof((bytes32,bytes,bytes32[],bytes,uint256[],uint256,string,string,bool))":{"notice":"Verifies a proof from ZKPassport"}},"version":1}},"settings":{"compilationTarget":{"src/ZKPassportVerifier.sol":"ZKPassportVerifier"},"evmVersion":"cancun","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":200},"remappings":[":forge-std/=lib/forge-std/src/"]},"sources":{"src/ArrayUtils.sol":{"keccak256":"0x8decadfca50750cbdcb00be06030305478292f0042affa868e733d85a3fc9882","license":"Apache-2.0","urls":["bzz-raw://87c9fef005d1894a5fd5dcb1dd46d9a8643ce7496f6aaed7e000fe7a518cf0d1","dweb:/ipfs/QmdCn9qvZXQDpBWcDXumLagWg5dEV5yE1DCMiE1PidqCBe"]},"src/DateUtils.sol":{"keccak256":"0xd3fe7fd4a910fe7ef1e4cf22e09a94b2cb1de70e9ccf4bc0015fa2d9da35da95","license":"Apache-2.0","urls":["bzz-raw://c842a171154773f3a56b4f0842fb7a9811b865dce05abad4060659db18553500","dweb:/ipfs/QmSs5UgmLUPSqL43khS7WbM15iKKAz4bwEpbEu319m9caL"]},"src/IRootRegistry.sol":{"keccak256":"0xa9955e80821ca9ccbdf7d05a8ce9a3e237b4771e1f6e09190ed1c803a5e1e516","license":"MIT","urls":["bzz-raw://fd9fc9fbd7057a6bcc16a682e52be9ebd012954898626a11f0a0e8788644789d","dweb:/ipfs/QmZYpMRHdv4gMCNXCQtGQu8XqRVtNR9Kgkzh7u1YMpvrEB"]},"src/OuterCount4.sol":{"keccak256":"0x5b0c5790560ca35d8e2cc4d546d96f26394715ebebce9af645373fd92c207bb7","license":"Apache-2.0","urls":["bzz-raw://52359801317456c1cd804564c46ad154e7e317ab12aeda3d5d5b6aeb8338425d","dweb:/ipfs/QmTNnxQ9L1nnnXeFm6ShxQoDsMm8htKuoeU5B4sAF1VzBq"]},"src/StringUtils.sol":{"keccak256":"0x518791675043f4c927aa2d02b543b8be56b77b9c0c9aab46dd8dcea45ee7e8d5","license":"Apache-2.0","urls":["bzz-raw://851a2758819d8cf3d3628fa6b43f3ae84c0f0a684c3a08dd3a640c0a4075268d","dweb:/ipfs/QmRZn415Bgyv6rcCfiZhfDNt6uDCgxCTMi48nU2KmDZBTb"]},"src/ZKPassportVerifier.sol":{"keccak256":"0x6d8cf82b75a01991928051283aa4e3486d2abc7bfa1fb86473b509befc96cf87","license":"Apache-2.0","urls":["bzz-raw://14437bd7a55b01f03c03f2267cbbf02ceff4f27c3745592bf12d96573acf73c6","dweb:/ipfs/QmWRX56rHi4Vm4h1322exjg6soQbt1dT1mPNv6VtdUM5tK"]}},"version":1}',
+  metadata: {
+    compiler: { version: "0.8.29+commit.ab55807c" },
+    language: "Solidity",
+    output: {
+      abi: [
+        {
+          inputs: [{ internalType: "address", name: "_rootRegistry", type: "address" }],
+          stateMutability: "nonpayable",
+          type: "constructor"
+        },
+        {
+          inputs: [
+            { internalType: "address", name: "oldAdmin", type: "address", indexed: true },
+            { internalType: "address", name: "newAdmin", type: "address", indexed: true }
+          ],
+          type: "event",
+          name: "AdminUpdated",
+          anonymous: false
+        },
+        {
+          inputs: [
+            {
+              internalType: "bytes32",
+              name: "certificateRegistryRoot",
+              type: "bytes32",
+              indexed: true
+            }
+          ],
+          type: "event",
+          name: "CertificateRegistryRootAdded",
+          anonymous: false
+        },
+        {
+          inputs: [
+            {
+              internalType: "bytes32",
+              name: "certificateRegistryRoot",
+              type: "bytes32",
+              indexed: true
+            }
+          ],
+          type: "event",
+          name: "CertificateRegistryRootRemoved",
+          anonymous: false
+        },
+        {
+          inputs: [
+            { internalType: "bool", name: "paused", type: "bool", indexed: false }
+          ],
+          type: "event",
+          name: "PausedStatusChanged",
+          anonymous: false
+        },
+        {
+          inputs: [
+            { internalType: "bytes32", name: "vkeyHash", type: "bytes32", indexed: true },
+            { internalType: "address", name: "verifier", type: "address", indexed: true }
+          ],
+          type: "event",
+          name: "VerifierAdded",
+          anonymous: false
+        },
+        {
+          inputs: [
+            { internalType: "bytes32", name: "vkeyHash", type: "bytes32", indexed: true }
+          ],
+          type: "event",
+          name: "VerifierRemoved",
+          anonymous: false
+        },
+        {
+          inputs: [
+            { internalType: "address", name: "admin", type: "address", indexed: true },
+            { internalType: "uint256", name: "timestamp", type: "uint256", indexed: false }
+          ],
+          type: "event",
+          name: "ZKPassportVerifierDeployed",
+          anonymous: false
+        },
+        {
+          inputs: [],
+          stateMutability: "view",
+          type: "function",
+          name: "CERTIFICATE_REGISTRY_ID",
+          outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }]
+        },
+        {
+          inputs: [],
+          stateMutability: "view",
+          type: "function",
+          name: "CIRCUIT_REGISTRY_ID",
+          outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }]
+        },
+        {
+          inputs: [
+            { internalType: "bytes32", name: "certificateRegistryRoot", type: "bytes32" }
+          ],
+          stateMutability: "nonpayable",
+          type: "function",
+          name: "addCertificateRegistryRoot"
+        },
+        {
+          inputs: [
+            { internalType: "bytes32[]", name: "vkeyHashes", type: "bytes32[]" },
+            { internalType: "address[]", name: "verifiers", type: "address[]" }
+          ],
+          stateMutability: "nonpayable",
+          type: "function",
+          name: "addVerifiers"
+        },
+        {
+          inputs: [],
+          stateMutability: "view",
+          type: "function",
+          name: "admin",
+          outputs: [{ internalType: "address", name: "", type: "address" }]
+        },
+        {
+          inputs: [
+            { internalType: "bytes", name: "committedInputs", type: "bytes" },
+            { internalType: "uint256[]", name: "committedInputCounts", type: "uint256[]" }
+          ],
+          stateMutability: "pure",
+          type: "function",
+          name: "getAgeProofInputs",
+          outputs: [
+            { internalType: "uint256", name: "currentDate", type: "uint256" },
+            { internalType: "uint8", name: "minAge", type: "uint8" },
+            { internalType: "uint8", name: "maxAge", type: "uint8" }
+          ]
+        },
+        {
+          inputs: [
+            { internalType: "bytes", name: "committedInputs", type: "bytes" },
+            { internalType: "uint256[]", name: "committedInputCounts", type: "uint256[]" }
+          ],
+          stateMutability: "pure",
+          type: "function",
+          name: "getBindProofInputs",
+          outputs: [{ internalType: "bytes", name: "data", type: "bytes" }]
+        },
+        {
+          inputs: [{ internalType: "bytes", name: "data", type: "bytes" }],
+          stateMutability: "pure",
+          type: "function",
+          name: "getBoundData",
+          outputs: [
+            { internalType: "address", name: "senderAddress", type: "address" },
+            { internalType: "string", name: "customData", type: "string" }
+          ]
+        },
+        {
+          inputs: [
+            { internalType: "bytes", name: "committedInputs", type: "bytes" },
+            { internalType: "uint256[]", name: "committedInputCounts", type: "uint256[]" },
+            { internalType: "enum ProofType", name: "proofType", type: "uint8" }
+          ],
+          stateMutability: "pure",
+          type: "function",
+          name: "getCountryProofInputs",
+          outputs: [{ internalType: "string[]", name: "countryList", type: "string[]" }]
+        },
+        {
+          inputs: [
+            { internalType: "bytes", name: "committedInputs", type: "bytes" },
+            { internalType: "uint256[]", name: "committedInputCounts", type: "uint256[]" },
+            { internalType: "enum ProofType", name: "proofType", type: "uint8" }
+          ],
+          stateMutability: "pure",
+          type: "function",
+          name: "getDateProofInputs",
+          outputs: [
+            { internalType: "uint256", name: "currentDate", type: "uint256" },
+            { internalType: "uint256", name: "minDate", type: "uint256" },
+            { internalType: "uint256", name: "maxDate", type: "uint256" }
+          ]
+        },
+        {
+          inputs: [
+            { internalType: "bytes", name: "committedInputs", type: "bytes" },
+            { internalType: "uint256[]", name: "committedInputCounts", type: "uint256[]" }
+          ],
+          stateMutability: "pure",
+          type: "function",
+          name: "getDiscloseProofInputs",
+          outputs: [
+            { internalType: "bytes", name: "discloseMask", type: "bytes" },
+            { internalType: "bytes", name: "discloseBytes", type: "bytes" }
+          ]
+        },
+        {
+          inputs: [
+            { internalType: "bytes", name: "discloseBytes", type: "bytes" },
+            { internalType: "bool", name: "isIDCard", type: "bool" }
+          ],
+          stateMutability: "pure",
+          type: "function",
+          name: "getDisclosedData",
+          outputs: [
+            { internalType: "string", name: "name", type: "string" },
+            { internalType: "string", name: "issuingCountry", type: "string" },
+            { internalType: "string", name: "nationality", type: "string" },
+            { internalType: "string", name: "gender", type: "string" },
+            { internalType: "string", name: "birthDate", type: "string" },
+            { internalType: "string", name: "expiryDate", type: "string" },
+            { internalType: "string", name: "documentNumber", type: "string" },
+            { internalType: "string", name: "documentType", type: "string" }
+          ]
+        },
+        {
+          inputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
+          stateMutability: "view",
+          type: "function",
+          name: "isValidCertificateRegistryRoot",
+          outputs: [{ internalType: "bool", name: "", type: "bool" }]
+        },
+        {
+          inputs: [],
+          stateMutability: "view",
+          type: "function",
+          name: "paused",
+          outputs: [{ internalType: "bool", name: "", type: "bool" }]
+        },
+        {
+          inputs: [
+            { internalType: "bytes32", name: "certificateRegistryRoot", type: "bytes32" }
+          ],
+          stateMutability: "nonpayable",
+          type: "function",
+          name: "removeCertificateRegistryRoot"
+        },
+        {
+          inputs: [{ internalType: "bytes32[]", name: "vkeyHashes", type: "bytes32[]" }],
+          stateMutability: "nonpayable",
+          type: "function",
+          name: "removeVerifiers"
+        },
+        {
+          inputs: [],
+          stateMutability: "view",
+          type: "function",
+          name: "rootRegistry",
+          outputs: [{ internalType: "contract IRootRegistry", name: "", type: "address" }]
+        },
+        {
+          inputs: [{ internalType: "bool", name: "_paused", type: "bool" }],
+          stateMutability: "nonpayable",
+          type: "function",
+          name: "setPaused"
+        },
+        {
+          inputs: [{ internalType: "address", name: "newAdmin", type: "address" }],
+          stateMutability: "nonpayable",
+          type: "function",
+          name: "transferAdmin"
+        },
+        {
+          inputs: [{ internalType: "address", name: "_rootRegistry", type: "address" }],
+          stateMutability: "nonpayable",
+          type: "function",
+          name: "updateRootRegistry"
+        },
+        {
+          inputs: [
+            {
+              internalType: "struct ProofVerificationParams",
+              name: "params",
+              type: "tuple",
+              components: [
+                { internalType: "bytes32", name: "vkeyHash", type: "bytes32" },
+                { internalType: "bytes", name: "proof", type: "bytes" },
+                { internalType: "bytes32[]", name: "publicInputs", type: "bytes32[]" },
+                { internalType: "bytes", name: "committedInputs", type: "bytes" },
+                {
+                  internalType: "uint256[]",
+                  name: "committedInputCounts",
+                  type: "uint256[]"
+                },
+                { internalType: "uint256", name: "validityPeriodInDays", type: "uint256" },
+                { internalType: "string", name: "domain", type: "string" },
+                { internalType: "string", name: "scope", type: "string" },
+                { internalType: "bool", name: "devMode", type: "bool" }
+              ]
+            }
+          ],
+          stateMutability: "view",
+          type: "function",
+          name: "verifyProof",
+          outputs: [
+            { internalType: "bool", name: "", type: "bool" },
+            { internalType: "bytes32", name: "", type: "bytes32" }
+          ]
+        },
+        {
+          inputs: [
+            { internalType: "bytes32[]", name: "publicInputs", type: "bytes32[]" },
+            { internalType: "string", name: "domain", type: "string" },
+            { internalType: "string", name: "scope", type: "string" }
+          ],
+          stateMutability: "view",
+          type: "function",
+          name: "verifyScopes",
+          outputs: [{ internalType: "bool", name: "", type: "bool" }]
+        },
+        {
+          inputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
+          stateMutability: "view",
+          type: "function",
+          name: "vkeyHashToVerifier",
+          outputs: [{ internalType: "address", name: "", type: "address" }]
+        }
+      ],
+      devdoc: {
+        kind: "dev",
+        methods: {
+          constructor: { details: "Constructor" },
+          "verifyProof((bytes32,bytes,bytes32[],bytes,uint256[],uint256,string,string,bool))": {
+            params: { params: "The proof verification parameters" },
+            returns: {
+              _0: "isValid True if the proof is valid, false otherwise",
+              _1: "uniqueIdentifier The unique identifier associated to the identity document that generated the proof"
+            }
+          }
+        },
+        version: 1
+      },
+      userdoc: {
+        kind: "user",
+        methods: {
+          "verifyProof((bytes32,bytes,bytes32[],bytes,uint256[],uint256,string,string,bool))": {
+            notice: "Verifies a proof from ZKPassport"
+          }
+        },
+        version: 1
+      }
+    },
+    settings: {
+      remappings: ["forge-std/=lib/forge-std/src/"],
+      optimizer: { enabled: true, runs: 200 },
+      metadata: { bytecodeHash: "ipfs" },
+      compilationTarget: { "src/ZKPassportVerifier.sol": "ZKPassportVerifier" },
+      evmVersion: "cancun",
+      libraries: {}
+    },
+    sources: {
+      "src/ArrayUtils.sol": {
+        keccak256: "0x8decadfca50750cbdcb00be06030305478292f0042affa868e733d85a3fc9882",
+        urls: [
+          "bzz-raw://87c9fef005d1894a5fd5dcb1dd46d9a8643ce7496f6aaed7e000fe7a518cf0d1",
+          "dweb:/ipfs/QmdCn9qvZXQDpBWcDXumLagWg5dEV5yE1DCMiE1PidqCBe"
+        ],
+        license: "Apache-2.0"
+      },
+      "src/DateUtils.sol": {
+        keccak256: "0xd3fe7fd4a910fe7ef1e4cf22e09a94b2cb1de70e9ccf4bc0015fa2d9da35da95",
+        urls: [
+          "bzz-raw://c842a171154773f3a56b4f0842fb7a9811b865dce05abad4060659db18553500",
+          "dweb:/ipfs/QmSs5UgmLUPSqL43khS7WbM15iKKAz4bwEpbEu319m9caL"
+        ],
+        license: "Apache-2.0"
+      },
+      "src/IRootRegistry.sol": {
+        keccak256: "0xa9955e80821ca9ccbdf7d05a8ce9a3e237b4771e1f6e09190ed1c803a5e1e516",
+        urls: [
+          "bzz-raw://fd9fc9fbd7057a6bcc16a682e52be9ebd012954898626a11f0a0e8788644789d",
+          "dweb:/ipfs/QmZYpMRHdv4gMCNXCQtGQu8XqRVtNR9Kgkzh7u1YMpvrEB"
+        ],
+        license: "MIT"
+      },
+      "src/OuterCount4.sol": {
+        keccak256: "0x5b0c5790560ca35d8e2cc4d546d96f26394715ebebce9af645373fd92c207bb7",
+        urls: [
+          "bzz-raw://52359801317456c1cd804564c46ad154e7e317ab12aeda3d5d5b6aeb8338425d",
+          "dweb:/ipfs/QmTNnxQ9L1nnnXeFm6ShxQoDsMm8htKuoeU5B4sAF1VzBq"
+        ],
+        license: "Apache-2.0"
+      },
+      "src/StringUtils.sol": {
+        keccak256: "0x518791675043f4c927aa2d02b543b8be56b77b9c0c9aab46dd8dcea45ee7e8d5",
+        urls: [
+          "bzz-raw://851a2758819d8cf3d3628fa6b43f3ae84c0f0a684c3a08dd3a640c0a4075268d",
+          "dweb:/ipfs/QmRZn415Bgyv6rcCfiZhfDNt6uDCgxCTMi48nU2KmDZBTb"
+        ],
+        license: "Apache-2.0"
+      },
+      "src/ZKPassportVerifier.sol": {
+        keccak256: "0x6d8cf82b75a01991928051283aa4e3486d2abc7bfa1fb86473b509befc96cf87",
+        urls: [
+          "bzz-raw://14437bd7a55b01f03c03f2267cbbf02ceff4f27c3745592bf12d96573acf73c6",
+          "dweb:/ipfs/QmWRX56rHi4Vm4h1322exjg6soQbt1dT1mPNv6VtdUM5tK"
+        ],
+        license: "Apache-2.0"
+      }
+    },
+    version: 1
+  },
+  id: 27
+};
+
+// src/index.ts
+var import_registry = require("@zkpassport/registry");
+var import_bridge = require("@obsidion/bridge");
+var import_utils4 = require("@zkpassport/utils");
+var VERSION = "0.5.5";
+var DEFAULT_DATE_VALUE = new Date(1111, 10, 11);
+if (typeof globalThis.Buffer === "undefined") {
+  globalThis.Buffer = import_buffer.Buffer;
+  if (typeof window !== "undefined") {
+    window.Buffer = import_buffer.Buffer;
+  }
+}
+function getChainIdFromEVMChain(chain) {
+  if (chain === "ethereum_sepolia") {
+    return 11155111;
+  } else if (chain === "local_anvil") {
+    return 31337;
+  }
+  throw new Error(`Unsupported chain: ${chain}`);
+}
+function getEVMChainFromChainId(chainId) {
+  if (chainId === 11155111) {
+    return "ethereum_sepolia";
+  } else if (chainId === 31337) {
+    return "local_anvil";
+  }
+  throw new Error(`Unsupported chain ID: ${chainId}`);
+}
+(0, import_i18n_iso_countries.registerLocale)(import_en.default);
+function hasRequestedAccessToField(credentialsRequest, field) {
+  const fieldValue = credentialsRequest[field];
+  const isDefined = fieldValue !== void 0 && fieldValue !== null;
+  if (!isDefined) {
+    return false;
+  }
+  for (const key in fieldValue) {
+    if (fieldValue[key] !== void 0 && fieldValue[key] !== null) {
+      return true;
+    }
+  }
+  return false;
+}
+function normalizeCountry(country) {
+  if (country === "Zero Knowledge Republic") {
+    return "ZKR";
+  }
+  let normalizedCountry;
+  const alpha3 = (0, import_i18n_iso_countries.getAlpha3Code)(country, "en");
+  normalizedCountry = alpha3 || country || "ZKR";
+  return normalizedCountry;
+}
+function numericalCompare(fnName, key, value, requestId, requestIdToConfig) {
+  requestIdToConfig[requestId][key] = {
+    ...requestIdToConfig[requestId][key],
+    [fnName]: value
+  };
+}
+function rangeCompare(key, value, requestId, requestIdToConfig) {
+  requestIdToConfig[requestId][key] = {
+    ...requestIdToConfig[requestId][key],
+    range: value
+  };
+}
+function generalCompare(fnName, key, value, requestId, requestIdToConfig) {
+  requestIdToConfig[requestId][key] = {
+    ...requestIdToConfig[requestId][key],
+    [fnName]: value
+  };
+}
+var ZKPassport = class {
+  //private wasmVerifierInit: boolean = false
+  constructor(_domain) {
+    this.topicToConfig = {};
+    this.topicToLocalConfig = {};
+    this.topicToPublicKey = {};
+    this.topicToBridge = {};
+    this.topicToRequestReceived = {};
+    this.topicToService = {};
+    this.topicToProofs = {};
+    this.topicToExpectedProofCount = {};
+    this.topicToFailedProofCount = {};
+    this.topicToResults = {};
+    this.onRequestReceivedCallbacks = {};
+    this.onGeneratingProofCallbacks = {};
+    this.onBridgeConnectCallbacks = {};
+    this.onProofGeneratedCallbacks = {};
+    this.onResultCallbacks = {};
+    this.onRejectCallbacks = {};
+    this.onErrorCallbacks = {};
+    if (!_domain && typeof window === "undefined") {
+      throw new Error("Domain argument is required in Node.js environment");
+    }
+    this.domain = _domain || window.location.hostname;
+  }
+  async handleResult(topic) {
+    const result = this.topicToResults[topic];
+    delete this.topicToResults[topic];
+    const { uniqueIdentifier, verified, queryResultErrors } = await this.verify({
+      proofs: this.topicToProofs[topic],
+      queryResult: result,
+      validity: this.topicToLocalConfig[topic]?.validity,
+      scope: this.topicToService[topic]?.scope,
+      evmChain: this.topicToService[topic]?.chainId ? getEVMChainFromChainId(this.topicToService[topic]?.chainId) : void 0,
+      devMode: this.topicToLocalConfig[topic]?.devMode
+    });
+    delete this.topicToProofs[topic];
+    const hasFailedProofs = this.topicToFailedProofCount[topic] > 0;
+    await Promise.all(
+      this.onResultCallbacks[topic].map(
+        (callback) => callback({
+          // If there are failed proofs, we don't return the unique identifier
+          // and we set the verified result to false
+          uniqueIdentifier: hasFailedProofs ? void 0 : uniqueIdentifier,
+          verified: hasFailedProofs ? false : verified,
+          result,
+          queryResultErrors
+        })
+      )
+    );
+    delete this.topicToExpectedProofCount[topic];
+    delete this.topicToFailedProofCount[topic];
+  }
+  setExpectedProofCount(topic) {
+    if (this.topicToLocalConfig[topic].mode !== "fast") {
+      this.topicToExpectedProofCount[topic] = 1;
+      return;
+    }
+    const fields = Object.keys(this.topicToConfig[topic]).filter(
+      (key) => hasRequestedAccessToField(this.topicToConfig[topic], key)
+    );
+    const neededCircuits = [];
+    for (const field of fields) {
+      for (const key in this.topicToConfig[topic][field]) {
+        switch (key) {
+          case "eq":
+          case "disclose":
+            if (field !== "age" && !neededCircuits.includes("disclose_bytes")) {
+              neededCircuits.push("disclose_bytes");
+            } else if (field === "age" && !neededCircuits.includes("compare_age")) {
+              neededCircuits.push("compare_age");
+            }
+            break;
+          case "gte":
+          case "gt":
+          case "lte":
+          case "lt":
+          case "range":
+            if (field === "age" && !neededCircuits.includes("compare_age")) {
+              neededCircuits.push("compare_age");
+            } else if (field === "expiry_date" && !neededCircuits.includes("compare_expiry")) {
+              neededCircuits.push("compare_expiry");
+            } else if (field === "birthdate" && !neededCircuits.includes("compare_birthdate")) {
+              neededCircuits.push("compare_birthdate");
+            }
+            break;
+          case "in":
+            if (field === "nationality" && !neededCircuits.includes("inclusion_check_nationality")) {
+              neededCircuits.push("inclusion_check_nationality");
+            } else if (field === "issuing_country" && !neededCircuits.includes("inclusion_check_issuing_country")) {
+              neededCircuits.push("inclusion_check_issuing_country");
+            }
+            break;
+          case "out":
+            if (field === "nationality" && !neededCircuits.includes("exclusion_check_nationality")) {
+              neededCircuits.push("exclusion_check_nationality");
+            } else if (field === "issuing_country" && !neededCircuits.includes("exclusion_check_issuing_country")) {
+              neededCircuits.push("exclusion_check_issuing_country");
+            }
+            break;
+        }
+      }
+    }
+    if (this.topicToConfig[topic].bind) {
+      neededCircuits.push("bind");
+    }
+    this.topicToExpectedProofCount[topic] = neededCircuits.length === 0 ? 4 : 3 + neededCircuits.length;
+    this.topicToFailedProofCount[topic] = 0;
+  }
+  /**
+   * @notice Handle an encrypted message.
+   * @param request The request.
+   * @param outerRequest The outer request.
+   */
+  async handleEncryptedMessage(topic, request) {
+    noLogger.debug("Received encrypted message:", request);
+    if (request.method === "accept") {
+      noLogger.debug(`User accepted the request and is generating a proof`);
+      await Promise.all(this.onGeneratingProofCallbacks[topic].map((callback) => callback(topic)));
+    } else if (request.method === "reject") {
+      noLogger.debug(`User rejected the request`);
+      await Promise.all(this.onRejectCallbacks[topic].map((callback) => callback()));
+    } else if (request.method === "proof") {
+      noLogger.debug(`User generated proof`);
+      this.topicToProofs[topic].push(request.params);
+      await Promise.all(
+        this.onProofGeneratedCallbacks[topic].map((callback) => callback(request.params))
+      );
+      if (this.topicToResults[topic] && this.topicToExpectedProofCount[topic] === this.topicToProofs[topic].length) {
+        await this.handleResult(topic);
+      }
+    } else if (request.method === "done") {
+      noLogger.debug(`User sent the query result`);
+      const formattedResult = request.params;
+      if (formattedResult.birthdate && formattedResult.birthdate.disclose) {
+        formattedResult.birthdate.disclose.result = new Date(
+          formattedResult.birthdate.disclose.result
+        );
+      }
+      if (formattedResult.expiry_date && formattedResult.expiry_date.disclose) {
+        formattedResult.expiry_date.disclose.result = new Date(
+          formattedResult.expiry_date.disclose.result
+        );
+      }
+      this.topicToResults[topic] = formattedResult;
+      if (this.topicToExpectedProofCount[topic] === this.topicToProofs[topic].length) {
+        await this.handleResult(topic);
+      }
+    } else if (request.method === "error") {
+      const error = request.params.error;
+      if (error && error === "This ID is not supported yet") {
+        this.topicToExpectedProofCount[topic] = 0;
+        this.topicToFailedProofCount[topic] += this.topicToExpectedProofCount[topic];
+        if (this.topicToResults[topic]) {
+          await this.handleResult(topic);
+        }
+      } else if (error && error.startsWith("Cannot generate proof")) {
+        this.topicToExpectedProofCount[topic] -= 1;
+        this.topicToFailedProofCount[topic] += 1;
+        if (this.topicToResults[topic] && this.topicToExpectedProofCount[topic] === this.topicToProofs[topic].length) {
+          await this.handleResult(topic);
+        }
+      }
+      await Promise.all(this.onErrorCallbacks[topic].map((callback) => callback(error)));
+    }
+  }
+  getZkPassportRequest(topic) {
+    return {
+      eq: (key, value) => {
+        if (key === "issuing_country" || key === "nationality") {
+          value = normalizeCountry(value);
+        }
+        generalCompare("eq", key, value, topic, this.topicToConfig);
+        return this.getZkPassportRequest(topic);
+      },
+      gte: (key, value) => {
+        numericalCompare("gte", key, value, topic, this.topicToConfig);
+        if (key === "age" && (value < 1 || value >= 100)) {
+          throw new Error("Age must be between 1 and 99 (inclusive)");
+        }
+        return this.getZkPassportRequest(topic);
+      },
+      /*gt: <T extends NumericalIDCredential>(key: T, value: IDCredentialValue<T>) => {
+        numericalCompare('gt', key, value, topic, this.topicToConfig)
+        return this.getZkPassportRequest(topic)
+      },*/
+      lte: (key, value) => {
+        numericalCompare("lte", key, value, topic, this.topicToConfig);
+        return this.getZkPassportRequest(topic);
+      },
+      lt: (key, value) => {
+        numericalCompare("lt", key, value, topic, this.topicToConfig);
+        return this.getZkPassportRequest(topic);
+      },
+      range: (key, start, end) => {
+        rangeCompare(key, [start, end], topic, this.topicToConfig);
+        return this.getZkPassportRequest(topic);
+      },
+      in: (key, value) => {
+        value = value.map((v) => normalizeCountry(v));
+        generalCompare("in", key, value, topic, this.topicToConfig);
+        return this.getZkPassportRequest(topic);
+      },
+      out: (key, value) => {
+        value = value.map((v) => normalizeCountry(v));
+        generalCompare("out", key, value, topic, this.topicToConfig);
+        return this.getZkPassportRequest(topic);
+      },
+      disclose: (key) => {
+        this.topicToConfig[topic][key] = {
+          ...this.topicToConfig[topic][key],
+          disclose: true
+        };
+        return this.getZkPassportRequest(topic);
+      },
+      bind: (key, value) => {
+        this.topicToConfig[topic].bind = {
+          ...this.topicToConfig[topic].bind,
+          [key]: value
+        };
+        return this.getZkPassportRequest(topic);
+      },
+      done: () => {
+        this.setExpectedProofCount(topic);
+        return {
+          url: this._getUrl(topic),
+          requestId: topic,
+          onRequestReceived: (callback) => this.onRequestReceivedCallbacks[topic].push(callback),
+          onGeneratingProof: (callback) => this.onGeneratingProofCallbacks[topic].push(callback),
+          onBridgeConnect: (callback) => this.onBridgeConnectCallbacks[topic].push(callback),
+          onProofGenerated: (callback) => this.onProofGeneratedCallbacks[topic].push(callback),
+          onResult: (callback) => this.onResultCallbacks[topic].push(callback),
+          onReject: (callback) => this.onRejectCallbacks[topic].push(callback),
+          onError: (callback) => this.onErrorCallbacks[topic].push(callback),
+          isBridgeConnected: () => this.topicToBridge[topic].isBridgeConnected(),
+          requestReceived: () => this.topicToRequestReceived[topic] === true
+        };
+      }
+    };
+  }
+  /**
+   * @notice Create a new request
+   * @param name Your service name
+   * @param logo The logo of your service
+   * @param purpose To explain what you want to do with the user's data
+   * @param scope Scope this request to a specific use case
+   * @param validity How many days ago should have the ID been last scanned by the user?
+   * @param devMode Whether to enable dev mode. This will allow you to verify mock proofs (i.e. from ZKR)
+   * @param evmChain The EVM chain to use for the request (if using the proof onchain)
+   * @returns The query builder object.
+   */
+  async request({
+    name,
+    logo,
+    purpose,
+    scope,
+    mode,
+    evmChain,
+    validity,
+    devMode,
+    topicOverride,
+    keyPairOverride,
+    cloudProverUrl,
+    bridgeUrl
+  }) {
+    const bridge = await import_bridge.Bridge.create({
+      keyPair: keyPairOverride,
+      bridgeId: topicOverride,
+      bridgeUrl
+    });
+    const topic = bridge.connection.getBridgeId();
+    this.topicToConfig[topic] = {};
+    this.topicToService[topic] = {
+      name,
+      logo,
+      purpose,
+      scope,
+      chainId: evmChain ? getChainIdFromEVMChain(evmChain) : void 0,
+      cloudProverUrl,
+      bridgeUrl
+    };
+    this.topicToProofs[topic] = [];
+    this.topicToExpectedProofCount[topic] = 0;
+    this.topicToLocalConfig[topic] = {
+      // Default to 6 months
+      validity: validity || 6 * 30,
+      mode: mode || "fast",
+      devMode: devMode || false
+    };
+    this.onRequestReceivedCallbacks[topic] = [];
+    this.onGeneratingProofCallbacks[topic] = [];
+    this.onBridgeConnectCallbacks[topic] = [];
+    this.onProofGeneratedCallbacks[topic] = [];
+    this.onResultCallbacks[topic] = [];
+    this.onRejectCallbacks[topic] = [];
+    this.onErrorCallbacks[topic] = [];
+    this.topicToPublicKey[topic] = bridge.getPublicKey();
+    this.topicToBridge[topic] = bridge;
+    bridge.onConnect(async (reconnection) => {
+      noLogger.debug("Bridge connected");
+      noLogger.debug("Is reconnection:", reconnection);
+      await Promise.all(this.onBridgeConnectCallbacks[topic].map((callback) => callback()));
+    });
+    bridge.onSecureChannelEstablished(async () => {
+      noLogger.debug("Secure channel established");
+      await Promise.all(this.onRequestReceivedCallbacks[topic].map((callback) => callback()));
+    });
+    bridge.onSecureMessage(async (message) => {
+      noLogger.debug("Received message:", message);
+      this.handleEncryptedMessage(topic, message);
+    });
+    return this.getZkPassportRequest(topic);
+  }
+  checkDiscloseBytesPublicInputs(proof, queryResult) {
+    const queryResultErrors = {
+      sig_check_dsc: {},
+      sig_check_id_data: {},
+      data_check_integrity: {},
+      disclose: {},
+      age: {},
+      birthdate: {},
+      expiry_date: {},
+      document_type: {},
+      issuing_country: {},
+      gender: {},
+      nationality: {},
+      firstname: {},
+      lastname: {},
+      fullname: {},
+      document_number: {},
+      outer: {},
+      bind: {}
+    };
+    let isCorrect = true;
+    const disclosedDataPassport = import_utils.DisclosedData.fromDisclosedBytes(
+      (proof.committedInputs?.disclose_bytes).disclosedBytes,
+      "passport"
+    );
+    const disclosedDataIDCard = import_utils.DisclosedData.fromDisclosedBytes(
+      (proof.committedInputs?.disclose_bytes).disclosedBytes,
+      "id_card"
+    );
+    if (queryResult.document_type) {
+      if (queryResult.document_type.eq && queryResult.document_type.eq.result && queryResult.document_type.eq.expected !== disclosedDataPassport.documentType) {
+        console.warn("Document type does not match the expected document type");
+        isCorrect = false;
+        queryResultErrors.document_type.eq = {
+          expected: `${queryResult.document_type.eq.expected}`,
+          received: `${disclosedDataPassport.documentType ?? disclosedDataIDCard.documentType}`,
+          message: "Document type does not match the expected document type"
+        };
+      }
+      if (queryResult.document_type.disclose?.result !== disclosedDataIDCard.documentType) {
+        console.warn("Document type does not match the disclosed document type in query result");
+        isCorrect = false;
+        queryResultErrors.document_type.disclose = {
+          expected: `${queryResult.document_type.disclose?.result}`,
+          received: `${disclosedDataIDCard.documentType ?? disclosedDataPassport.documentType}`,
+          message: "Document type does not match the disclosed document type in query result"
+        };
+      }
+    }
+    if (queryResult.birthdate) {
+      const birthdatePassport = disclosedDataPassport.dateOfBirth;
+      const birthdateIDCard = disclosedDataIDCard.dateOfBirth;
+      if (queryResult.birthdate.eq && queryResult.birthdate.eq.result && queryResult.birthdate.eq.expected.getTime() !== birthdatePassport.getTime() && queryResult.birthdate.eq.expected.getTime() !== birthdateIDCard.getTime()) {
+        console.warn("Birthdate does not match the expected birthdate");
+        isCorrect = false;
+        queryResultErrors.birthdate.eq = {
+          expected: `${queryResult.birthdate.eq.expected.toISOString()}`,
+          received: `${birthdatePassport?.toISOString() ?? birthdateIDCard?.toISOString()}`,
+          message: "Birthdate does not match the expected birthdate"
+        };
+      }
+      if (queryResult.birthdate.disclose && queryResult.birthdate.disclose.result.getTime() !== birthdatePassport.getTime() && queryResult.birthdate.disclose.result.getTime() !== birthdateIDCard.getTime()) {
+        console.warn("Birthdate does not match the disclosed birthdate in query result");
+        isCorrect = false;
+        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 && queryResult.expiry_date.eq.expected.getTime() !== expiryDatePassport.getTime() && queryResult.expiry_date.eq.expected.getTime() !== expiryDateIDCard.getTime()) {
+        console.warn("Expiry date does not match the expected expiry date");
+        isCorrect = false;
+        queryResultErrors.expiry_date.eq = {
+          expected: `${queryResult.expiry_date.eq.expected.toISOString()}`,
+          received: `${expiryDatePassport?.toISOString() ?? expiryDateIDCard?.toISOString()}`,
+          message: "Expiry date does not match the expected expiry date"
+        };
+      }
+      if (queryResult.expiry_date.disclose && queryResult.expiry_date.disclose.result.getTime() !== expiryDatePassport.getTime() && queryResult.expiry_date.disclose.result.getTime() !== expiryDateIDCard.getTime()) {
+        console.warn("Expiry date does not match the disclosed expiry date in query result");
+        isCorrect = false;
+        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.eq = {
+          expected: `${queryResult.nationality.eq.expected}`,
+          received: `${nationalityPassport ?? nationalityIDCard}`,
+          message: "Nationality does not match the expected nationality"
+        };
+      }
+      if (queryResult.nationality.disclose && queryResult.nationality.disclose.result !== nationalityPassport && queryResult.nationality.disclose.result !== nationalityIDCard) {
+        console.warn("Nationality does not match the disclosed nationality in query result");
+        isCorrect = false;
+        queryResultErrors.nationality.disclose = {
+          expected: `${queryResult.nationality.disclose.result}`,
+          received: `${nationalityPassport ?? nationalityIDCard}`,
+          message: "Nationality does not match the disclosed nationality in query result"
+        };
+      }
+    }
+    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.eq = {
+          expected: `${queryResult.document_number.eq.expected}`,
+          received: `${documentNumberPassport ?? documentNumberIDCard}`,
+          message: "Document number does not match the expected document number"
+        };
+      }
+      if (queryResult.document_number.disclose && queryResult.document_number.disclose.result !== documentNumberPassport && queryResult.document_number.disclose.result !== documentNumberIDCard) {
+        console.warn("Document number does not match the disclosed document number in query result");
+        isCorrect = false;
+        queryResultErrors.document_number.disclose = {
+          expected: `${queryResult.document_number.disclose.result}`,
+          received: `${documentNumberPassport ?? documentNumberIDCard}`,
+          message: "Document number does not match the disclosed document number in query result"
+        };
+      }
+    }
+    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.eq = {
+          expected: `${queryResult.gender.eq.expected}`,
+          received: `${genderPassport ?? genderIDCard}`,
+          message: "Gender does not match the expected gender"
+        };
+      }
+      if (queryResult.gender.disclose && queryResult.gender.disclose.result !== genderPassport && queryResult.gender.disclose.result !== genderIDCard) {
+        console.warn("Gender does not match the disclosed gender in query result");
+        isCorrect = false;
+        queryResultErrors.gender.disclose = {
+          expected: `${queryResult.gender.disclose.result}`,
+          received: `${genderPassport ?? genderIDCard}`,
+          message: "Gender does not match the disclosed gender in query result"
+        };
+      }
+    }
+    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.eq = {
+          expected: `${queryResult.issuing_country.eq.expected}`,
+          received: `${issuingCountryPassport ?? issuingCountryIDCard}`,
+          message: "Issuing country does not match the expected issuing country"
+        };
+      }
+      if (queryResult.issuing_country.disclose && queryResult.issuing_country.disclose.result !== issuingCountryPassport && queryResult.issuing_country.disclose.result !== issuingCountryIDCard) {
+        console.warn("Issuing country does not match the disclosed issuing country in query result");
+        isCorrect = false;
+        queryResultErrors.issuing_country.disclose = {
+          expected: `${queryResult.issuing_country.disclose.result}`,
+          received: `${issuingCountryPassport ?? issuingCountryIDCard}`,
+          message: "Issuing country does not match the disclosed issuing country in query result"
+        };
+      }
+    }
+    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.eq = {
+          expected: `${queryResult.fullname.eq.expected}`,
+          received: `${fullnamePassport ?? fullnameIDCard}`,
+          message: "Fullname does not match the expected fullname"
+        };
+      }
+      if (queryResult.fullname.disclose && (0, import_utils.formatName)(queryResult.fullname.disclose.result).toLowerCase() !== fullnamePassport.toLowerCase() && (0, import_utils.formatName)(queryResult.fullname.disclose.result).toLowerCase() !== fullnameIDCard.toLowerCase()) {
+        console.warn("Fullname does not match the disclosed fullname in query result");
+        isCorrect = false;
+        queryResultErrors.fullname.disclose = {
+          expected: `${queryResult.fullname.disclose.result}`,
+          received: `${fullnamePassport ?? fullnameIDCard}`,
+          message: "Fullname does not match the disclosed fullname in query result"
+        };
+      }
+    }
+    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.eq = {
+          expected: `${queryResult.firstname.eq.expected}`,
+          received: `${firstnamePassport ?? firstnameIDCard}`,
+          message: "Firstname does not match the expected firstname"
+        };
+      }
+      if (queryResult.firstname.disclose && (0, import_utils.formatName)(queryResult.firstname.disclose.result).toLowerCase() !== firstnamePassport.toLowerCase() && (0, import_utils.formatName)(queryResult.firstname.disclose.result).toLowerCase() !== firstnameIDCard.toLowerCase()) {
+        console.warn("Firstname does not match the disclosed firstname in query result");
+        isCorrect = false;
+        queryResultErrors.firstname.disclose = {
+          expected: `${queryResult.firstname.disclose.result}`,
+          received: `${firstnamePassport ?? firstnameIDCard}`,
+          message: "Firstname does not match the disclosed firstname in query result"
+        };
+      }
+    }
+    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.eq = {
+          expected: `${queryResult.lastname.eq.expected}`,
+          received: `${lastnamePassport ?? lastnameIDCard}`,
+          message: "Lastname does not match the expected lastname"
+        };
+      }
+      if (queryResult.lastname.disclose && (0, import_utils.formatName)(queryResult.lastname.disclose.result).toLowerCase() !== lastnamePassport.toLowerCase() && (0, import_utils.formatName)(queryResult.lastname.disclose.result).toLowerCase() !== lastnameIDCard.toLowerCase()) {
+        console.warn("Lastname does not match the disclosed lastname in query result");
+        isCorrect = false;
+        queryResultErrors.lastname.disclose = {
+          expected: `${queryResult.lastname.disclose.result}`,
+          received: `${lastnamePassport ?? lastnameIDCard}`,
+          message: "Lastname does not match the disclosed lastname in query result"
+        };
+      }
+    }
+    return { isCorrect, queryResultErrors };
+  }
+  checkAgePublicInputs(proof, queryResult) {
+    const queryResultErrors = {
+      sig_check_dsc: {},
+      sig_check_id_data: {},
+      data_check_integrity: {},
+      disclose: {},
+      age: {},
+      birthdate: {},
+      expiry_date: {},
+      document_type: {},
+      issuing_country: {},
+      gender: {},
+      nationality: {},
+      firstname: {},
+      lastname: {},
+      fullname: {},
+      document_number: {},
+      outer: {},
+      bind: {}
+    };
+    let isCorrect = true;
+    const currentTime = /* @__PURE__ */ new Date();
+    const today = new Date(
+      currentTime.getFullYear(),
+      currentTime.getMonth(),
+      currentTime.getDate(),
+      0,
+      0,
+      0,
+      0
+    );
+    const minAge = (0, import_utils.getMinAgeFromCommittedInputs)(
+      proof.committedInputs?.compare_age
+    );
+    const maxAge = (0, import_utils.getMaxAgeFromCommittedInputs)(
+      proof.committedInputs?.compare_age
+    );
+    if (queryResult.age) {
+      if (queryResult.age.gte && queryResult.age.gte.result && minAge !== queryResult.age.gte.expected) {
+        console.warn("Age is not greater than or equal to the expected age");
+        isCorrect = false;
+        queryResultErrors.age.gte = {
+          expected: queryResult.age.gte.expected,
+          received: minAge,
+          message: "Age is not greater than or equal to the expected age"
+        };
+      }
+      if (queryResult.age.lt && queryResult.age.lt.result && maxAge !== queryResult.age.lt.expected) {
+        console.warn("Age is not less than the expected age");
+        isCorrect = false;
+        queryResultErrors.age.lt = {
+          expected: queryResult.age.lt.expected,
+          received: maxAge,
+          message: "Age is not less than the expected age"
+        };
+      }
+      if (queryResult.age.range) {
+        if (queryResult.age.range.result && (minAge !== queryResult.age.range.expected[0] || maxAge !== queryResult.age.range.expected[1])) {
+          console.warn("Age is not in the expected range");
+          isCorrect = false;
+          queryResultErrors.age.range = {
+            expected: queryResult.age.range.expected,
+            received: [minAge, maxAge],
+            message: "Age is not in the expected range"
+          };
+        }
+      }
+      if (!queryResult.age.lt && !queryResult.age.range && maxAge != 0) {
+        console.warn("Maximum age should be equal to 0");
+        isCorrect = false;
+        queryResultErrors.age.disclose = {
+          expected: 0,
+          received: maxAge,
+          message: "Maximum age should be equal to 0"
+        };
+      }
+      if (!queryResult.age.gte && !queryResult.age.range && minAge != 0) {
+        console.warn("Minimum age should be equal to 0");
+        isCorrect = false;
+        queryResultErrors.age.disclose = {
+          expected: 0,
+          received: minAge,
+          message: "Minimum age should be equal to 0"
+        };
+      }
+      if (queryResult.age.disclose && (queryResult.age.disclose.result !== minAge || queryResult.age.disclose.result !== maxAge)) {
+        console.warn("Age does not match the disclosed age in query result");
+        isCorrect = false;
+        queryResultErrors.age.disclose = {
+          expected: `${minAge}`,
+          received: `${queryResult.age.disclose.result}`,
+          message: "Age does not match the disclosed age in query result"
+        };
+      }
+    } else {
+      console.warn("Age is not set in the query result");
+      isCorrect = false;
+      queryResultErrors.age.disclose = {
+        message: "Age is not set in the query result"
+      };
+    }
+    const currentDate = (0, import_utils.getCurrentDateFromCommittedInputs)(
+      proof.committedInputs?.compare_age
+    );
+    if (currentDate.getTime() !== today.getTime() && currentDate.getTime() !== today.getTime() - 864e5) {
+      console.warn("Current date in the proof is too old");
+      isCorrect = false;
+      queryResultErrors.age.disclose = {
+        expected: `${today.toISOString()}`,
+        received: `${currentDate.toISOString()}`,
+        message: "Current date in the proof is too old"
+      };
+    }
+    return { isCorrect, queryResultErrors };
+  }
+  checkBirthdatePublicInputs(proof, queryResult) {
+    const queryResultErrors = {
+      sig_check_dsc: {},
+      sig_check_id_data: {},
+      data_check_integrity: {},
+      disclose: {},
+      age: {},
+      birthdate: {},
+      expiry_date: {},
+      document_type: {},
+      issuing_country: {},
+      gender: {},
+      nationality: {},
+      firstname: {},
+      lastname: {},
+      fullname: {},
+      document_number: {},
+      outer: {},
+      bind: {}
+    };
+    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_birthdate
+    );
+    const maxDate = (0, import_utils.getMaxDateFromCommittedInputs)(
+      proof.committedInputs?.compare_birthdate
+    );
+    const currentDate = (0, import_utils.getCurrentDateFromCommittedInputs)(
+      proof.committedInputs?.compare_birthdate
+    );
+    if (queryResult.birthdate) {
+      if (queryResult.birthdate.gte && queryResult.birthdate.gte.result && minDate !== queryResult.birthdate.gte.expected) {
+        console.warn("Birthdate is not greater than or equal to the expected birthdate");
+        isCorrect = false;
+        queryResultErrors.birthdate.gte = {
+          expected: queryResult.birthdate.gte.expected,
+          received: minDate,
+          message: "Birthdate is not greater than or equal to the expected birthdate"
+        };
+      }
+      if (queryResult.birthdate.lte && queryResult.birthdate.lte.result && maxDate !== queryResult.birthdate.lte.expected) {
+        console.warn("Birthdate is not less than the expected birthdate");
+        isCorrect = false;
+        queryResultErrors.birthdate.lte = {
+          expected: queryResult.birthdate.lte.expected,
+          received: maxDate,
+          message: "Birthdate is not less than the expected birthdate"
+        };
+      }
+      if (queryResult.birthdate.range) {
+        if (queryResult.birthdate.range.result && (minDate !== queryResult.birthdate.range.expected[0] || maxDate !== queryResult.birthdate.range.expected[1])) {
+          console.warn("Birthdate is not in the expected range");
+          isCorrect = false;
+          queryResultErrors.birthdate.range = {
+            expected: queryResult.birthdate.range.expected,
+            received: [minDate, maxDate],
+            message: "Birthdate is not in the expected range"
+          };
+        }
+      }
+      if (!queryResult.birthdate.lte && !queryResult.birthdate.range && maxDate.getTime() != DEFAULT_DATE_VALUE.getTime()) {
+        console.warn("Maximum birthdate should be equal to default date value");
+        isCorrect = false;
+        queryResultErrors.birthdate.disclose = {
+          expected: `${DEFAULT_DATE_VALUE.toISOString()}`,
+          received: `${maxDate.toISOString()}`,
+          message: "Maximum birthdate should be equal to default date value"
+        };
+      }
+      if (!queryResult.birthdate.gte && !queryResult.birthdate.range && minDate.getTime() != DEFAULT_DATE_VALUE.getTime()) {
+        console.warn("Minimum birthdate should be equal to default date value");
+        isCorrect = false;
+        queryResultErrors.birthdate.disclose = {
+          expected: `${DEFAULT_DATE_VALUE.toISOString()}`,
+          received: `${minDate.toISOString()}`,
+          message: "Minimum birthdate should be equal to default date value"
+        };
+      }
+    } else {
+      console.warn("Birthdate is not set in the query result");
+      isCorrect = false;
+      queryResultErrors.birthdate.disclose = {
+        message: "Birthdate is not set in the query result"
+      };
+    }
+    if (currentDate.getTime() !== today.getTime() && currentDate.getTime() !== today.getTime() - 864e5) {
+      console.warn("Current date in the proof is too old");
+      isCorrect = false;
+      queryResultErrors.age.disclose = {
+        expected: `${today.toISOString()}`,
+        received: `${currentDate.toISOString()}`,
+        message: "Current date in the proof is too old"
+      };
+    }
+    return { isCorrect, queryResultErrors };
+  }
+  checkExpiryDatePublicInputs(proof, queryResult) {
+    const queryResultErrors = {
+      sig_check_dsc: {},
+      sig_check_id_data: {},
+      data_check_integrity: {},
+      disclose: {},
+      age: {},
+      birthdate: {},
+      expiry_date: {},
+      document_type: {},
+      issuing_country: {},
+      gender: {},
+      nationality: {},
+      firstname: {},
+      lastname: {},
+      fullname: {},
+      document_number: {},
+      outer: {},
+      bind: {}
+    };
+    let isCorrect = true;
+    const currentTime = /* @__PURE__ */ new Date();
+    const today = new Date(
+      currentTime.getFullYear(),
+      currentTime.getMonth(),
+      currentTime.getDate(),
+      0,
+      0,
+      0
+    );
+    const minDate = (0, import_utils.getMinDateFromCommittedInputs)(
+      proof.committedInputs?.compare_expiry
+    );
+    const maxDate = (0, import_utils.getMaxDateFromCommittedInputs)(
+      proof.committedInputs?.compare_expiry
+    );
+    const currentDate = (0, import_utils.getCurrentDateFromCommittedInputs)(
+      proof.committedInputs?.compare_expiry
+    );
+    if (queryResult.expiry_date) {
+      if (queryResult.expiry_date.gte && queryResult.expiry_date.gte.result && minDate !== queryResult.expiry_date.gte.expected) {
+        console.warn("Expiry date is not greater than or equal to the expected expiry date");
+        isCorrect = false;
+        queryResultErrors.expiry_date.gte = {
+          expected: queryResult.expiry_date.gte.expected,
+          received: minDate,
+          message: "Expiry date is not greater than or equal to the expected expiry date"
+        };
+      }
+      if (queryResult.expiry_date.lte && queryResult.expiry_date.lte.result && maxDate !== queryResult.expiry_date.lte.expected) {
+        console.warn("Expiry date is not less than the expected expiry date");
+        isCorrect = false;
+        queryResultErrors.expiry_date.lte = {
+          expected: queryResult.expiry_date.lte.expected,
+          received: maxDate,
+          message: "Expiry date is not less than the expected expiry date"
+        };
+      }
+      if (queryResult.expiry_date.range) {
+        if (queryResult.expiry_date.range.result && (minDate !== queryResult.expiry_date.range.expected[0] || maxDate !== queryResult.expiry_date.range.expected[1])) {
+          console.warn("Expiry date is not in the expected range");
+          isCorrect = false;
+          queryResultErrors.expiry_date.range = {
+            expected: queryResult.expiry_date.range.expected,
+            received: [minDate, maxDate],
+            message: "Expiry date is not in the expected range"
+          };
+        }
+      }
+      if (!queryResult.expiry_date.lte && !queryResult.expiry_date.range && maxDate.getTime() != DEFAULT_DATE_VALUE.getTime()) {
+        console.warn("Maximum expiry date should be equal to default date value");
+        isCorrect = false;
+        queryResultErrors.expiry_date.disclose = {
+          expected: `${DEFAULT_DATE_VALUE.toISOString()}`,
+          received: `${maxDate.toISOString()}`,
+          message: "Maximum expiry date should be equal to default date value"
+        };
+      }
+      if (!queryResult.expiry_date.gte && !queryResult.expiry_date.range && minDate.getTime() != DEFAULT_DATE_VALUE.getTime()) {
+        console.warn("Minimum expiry date should be equal to default date value");
+        isCorrect = false;
+        queryResultErrors.expiry_date.disclose = {
+          expected: `${DEFAULT_DATE_VALUE.toISOString()}`,
+          received: `${minDate.toISOString()}`,
+          message: "Minimum expiry date should be equal to default date value"
+        };
+      }
+    } else {
+      console.warn("Expiry date is not set in the query result");
+      isCorrect = false;
+      queryResultErrors.expiry_date.disclose = {
+        message: "Expiry date is not set in the query result"
+      };
+    }
+    if (currentDate.getTime() !== today.getTime() && currentDate.getTime() !== today.getTime() - 864e5) {
+      console.warn("Current date in the proof is too old");
+      isCorrect = false;
+      queryResultErrors.age.disclose = {
+        expected: `${today.toISOString()}`,
+        received: `${currentDate.toISOString()}`,
+        message: "Current date in the proof is too old"
+      };
+    }
+    return { isCorrect, queryResultErrors };
+  }
+  checkNationalityExclusionPublicInputs(queryResult, countryList) {
+    const queryResultErrors = {
+      sig_check_dsc: {},
+      sig_check_id_data: {},
+      data_check_integrity: {},
+      disclose: {},
+      age: {},
+      birthdate: {},
+      expiry_date: {},
+      document_type: {},
+      issuing_country: {},
+      gender: {},
+      nationality: {},
+      firstname: {},
+      lastname: {},
+      fullname: {},
+      document_number: {},
+      outer: {},
+      bind: {}
+    };
+    let isCorrect = true;
+    if (queryResult.nationality && queryResult.nationality.out && queryResult.nationality.out.result) {
+      if (!queryResult.nationality.out.expected?.every((country) => countryList.includes(country))) {
+        console.warn("Nationality exclusion list does not match the one from the query results");
+        isCorrect = false;
+        queryResultErrors.nationality.out = {
+          expected: queryResult.nationality.out.expected,
+          received: countryList,
+          message: "Nationality exclusion list does not match the one from the query results"
+        };
+      }
+    } else if (!queryResult.nationality || !queryResult.nationality.out) {
+      console.warn("Nationality exclusion is not set in the query result");
+      isCorrect = false;
+      queryResultErrors.nationality.out = {
+        message: "Nationality exclusion is not set in the query result"
+      };
+    }
+    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.out = {
+          message: "The nationality exclusion list has not been sorted, and thus the proof cannot be trusted"
+        };
+      }
+    }
+    return { isCorrect, queryResultErrors };
+  }
+  checkIssuingCountryExclusionPublicInputs(queryResult, countryList) {
+    const queryResultErrors = {
+      sig_check_dsc: {},
+      sig_check_id_data: {},
+      data_check_integrity: {},
+      disclose: {},
+      age: {},
+      birthdate: {},
+      expiry_date: {},
+      document_type: {},
+      issuing_country: {},
+      gender: {},
+      nationality: {},
+      firstname: {},
+      lastname: {},
+      fullname: {},
+      document_number: {},
+      outer: {},
+      bind: {}
+    };
+    let isCorrect = true;
+    if (queryResult.issuing_country && queryResult.issuing_country.out && queryResult.issuing_country.out.result) {
+      if (!queryResult.issuing_country.out.expected?.every((country) => countryList.includes(country))) {
+        console.warn("Issuing country exclusion list does not match the one from the query results");
+        isCorrect = false;
+        queryResultErrors.issuing_country.out = {
+          expected: queryResult.issuing_country.out.expected,
+          received: countryList,
+          message: "Issuing country exclusion list does not match the one from the query results"
+        };
+      }
+    } else if (!queryResult.issuing_country || !queryResult.issuing_country.out) {
+      console.warn("Issuing country exclusion is not set in the query result");
+      isCorrect = false;
+      queryResultErrors.issuing_country.out = {
+        message: "Issuing country exclusion is not set in the query result"
+      };
+    }
+    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.out = {
+          message: "The issuing country exclusion list has not been sorted, and thus the proof cannot be trusted"
+        };
+      }
+    }
+    return { isCorrect, queryResultErrors };
+  }
+  checkNationalityInclusionPublicInputs(queryResult, countryList) {
+    const queryResultErrors = {
+      sig_check_dsc: {},
+      sig_check_id_data: {},
+      data_check_integrity: {},
+      disclose: {},
+      age: {},
+      birthdate: {},
+      expiry_date: {},
+      document_type: {},
+      issuing_country: {},
+      gender: {},
+      nationality: {},
+      firstname: {},
+      lastname: {},
+      fullname: {},
+      document_number: {},
+      outer: {},
+      bind: {}
+    };
+    let isCorrect = true;
+    if (queryResult.nationality && queryResult.nationality.in && queryResult.nationality.in.result) {
+      if (!queryResult.nationality.in.expected?.every((country) => countryList.includes(country))) {
+        console.warn("Nationality inclusion list does not match the one from the query results");
+        isCorrect = false;
+        queryResultErrors.nationality.in = {
+          expected: queryResult.nationality.in.expected,
+          received: countryList,
+          message: "Nationality inclusion list does not match the one from the query results"
+        };
+      }
+    } else if (!queryResult.nationality || !queryResult.nationality.in) {
+      console.warn("Nationality inclusion is not set in the query result");
+      isCorrect = false;
+      queryResultErrors.nationality.in = {
+        message: "Nationality inclusion is not set in the query result"
+      };
+    }
+    return { isCorrect, queryResultErrors };
+  }
+  checkIssuingCountryInclusionPublicInputs(queryResult, countryList) {
+    const queryResultErrors = {
+      sig_check_dsc: {},
+      sig_check_id_data: {},
+      data_check_integrity: {},
+      disclose: {},
+      age: {},
+      birthdate: {},
+      expiry_date: {},
+      document_type: {},
+      issuing_country: {},
+      gender: {},
+      nationality: {},
+      firstname: {},
+      lastname: {},
+      fullname: {},
+      document_number: {},
+      outer: {},
+      bind: {}
+    };
+    let isCorrect = true;
+    if (queryResult.issuing_country && queryResult.issuing_country.in && queryResult.issuing_country.in.result) {
+      if (!queryResult.issuing_country.in.expected?.every((country) => countryList.includes(country))) {
+        console.warn("Issuing country inclusion list does not match the one from the query results");
+        isCorrect = false;
+        queryResultErrors.issuing_country.in = {
+          expected: queryResult.issuing_country.in.expected,
+          received: countryList,
+          message: "Issuing country inclusion list does not match the one from the query results"
+        };
+      }
+    } else if (!queryResult.issuing_country || !queryResult.issuing_country.in) {
+      console.warn("Issuing country inclusion is not set in the query result");
+      isCorrect = false;
+      queryResultErrors.issuing_country.in = {
+        message: "Issuing country inclusion is not set in the query result"
+      };
+    }
+    return { isCorrect, queryResultErrors };
+  }
+  checkScopeFromDisclosureProof(proofData, queryResultErrors, key, scope, chainId) {
+    let isCorrect = true;
+    if (this.domain && (0, import_utils.getServiceScopeHash)(this.domain, chainId) !== BigInt(proofData.publicInputs[1])) {
+      console.warn("The proof comes from a different domain than the one expected");
+      isCorrect = false;
+      queryResultErrors[key].scope = {
+        expected: `Scope: ${(0, import_utils.getServiceScopeHash)(this.domain, chainId).toString()}`,
+        received: `Scope: ${BigInt(proofData.publicInputs[1]).toString()}`,
+        message: "The proof comes from a different domain than the one expected"
+      };
+    }
+    if (scope && (0, import_utils.getScopeHash)(scope) !== BigInt(proofData.publicInputs[2])) {
+      console.warn("The proof uses a different scope than the one expected");
+      isCorrect = false;
+      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 };
+  }
+  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;
+        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;
+      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 };
+  }
+  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 };
+  }
+  checkBindPublicInputs(queryResult, boundData) {
+    const queryResultErrors = {
+      sig_check_dsc: {},
+      sig_check_id_data: {},
+      data_check_integrity: {},
+      disclose: {},
+      age: {},
+      birthdate: {},
+      expiry_date: {},
+      document_type: {},
+      issuing_country: {},
+      gender: {},
+      nationality: {},
+      firstname: {},
+      lastname: {},
+      fullname: {},
+      document_number: {},
+      outer: {},
+      bind: {}
+    };
+    let isCorrect = true;
+    if (queryResult.bind) {
+      if (queryResult.bind.user_address?.toLowerCase().replace("0x", "") !== boundData.user_address?.toLowerCase().replace("0x", "")) {
+        console.warn("Bound user address does not match the one from the query results");
+        isCorrect = false;
+        queryResultErrors.bind.eq = {
+          expected: queryResult.bind.user_address,
+          received: boundData.user_address,
+          message: "Bound user address does not match the one from the query results"
+        };
+      }
+      if (queryResult.bind.custom_data?.trim().toLowerCase() !== boundData.custom_data?.trim().toLowerCase()) {
+        console.warn("Bound custom data does not match the one from the query results");
+        isCorrect = false;
+        queryResultErrors.bind.eq = {
+          expected: queryResult.bind.custom_data,
+          received: boundData.custom_data,
+          message: "Bound custom data does not match the one from the query results"
+        };
+      }
+    }
+    return { isCorrect, queryResultErrors };
+  }
+  async checkPublicInputs(proofs, queryResult, validity, scope, chainId) {
+    let commitmentIn;
+    let commitmentOut;
+    let isCorrect = true;
+    let uniqueIdentifier;
+    const currentTime = /* @__PURE__ */ new Date();
+    const today = new Date(
+      currentTime.getFullYear(),
+      currentTime.getMonth(),
+      currentTime.getDate(),
+      0,
+      0,
+      0,
+      0
+    );
+    let queryResultErrors = {
+      sig_check_dsc: {},
+      sig_check_id_data: {},
+      data_check_integrity: {},
+      disclose: {},
+      age: {},
+      birthdate: {},
+      expiry_date: {},
+      document_type: {},
+      issuing_country: {},
+      gender: {},
+      nationality: {},
+      firstname: {},
+      lastname: {},
+      fullname: {},
+      document_number: {},
+      outer: {},
+      bind: {}
+    };
+    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"
+      ];
+      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 differenceInDays = validity ?? 180;
+        const expectedDifference = differenceInDays * 864e5;
+        const actualDifference = today.getTime() - (today.getTime() - expectedDifference);
+        if (todayToCurrentDate >= actualDifference) {
+          console.warn(
+            `The date used to check the validity of the ID is older than ${differenceInDays} days. You can ask the user to rescan their ID or ask them to disclose their expiry date`
+          );
+          isCorrect = false;
+          queryResultErrors.outer.date = {
+            expected: `Difference: ${differenceInDays} days`,
+            received: `Difference: ${Math.round(todayToCurrentDate / 864e5)} days`,
+            message: "The date used to check the validity of the ID is older than the validity period"
+          };
+        }
+        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.commitment = {
+            expected: `Number of parameter commitments: ${paramCommitments.length}`,
+            received: `Number of disclosure proofs provided: ${keysInCommittedInputs.length}`,
+            message: "The proof does not verify all the requested conditions and information"
+          };
+        }
+        if (this.domain && (0, import_utils.getServiceScopeHash)(this.domain, chainId) !== (0, import_utils.getScopeFromOuterProof)(proofData)) {
+          console.warn("The proof comes from a different domain than the one expected");
+          isCorrect = false;
+          queryResultErrors.outer.scope = {
+            expected: `Scope: ${(0, import_utils.getServiceScopeHash)(this.domain, chainId).toString()}`,
+            received: `Scope: ${(0, import_utils.getScopeFromOuterProof)(proofData).toString()}`,
+            message: "The proof comes from a different domain than the one expected"
+          };
+        }
+        if (scope && (0, import_utils.getScopeHash)(scope) !== (0, import_utils.getSubscopeFromOuterProof)(proofData)) {
+          console.warn("The proof uses a different scope than the one expected");
+          isCorrect = false;
+          queryResultErrors.outer.scope = {
+            expected: `Scope: ${(0, import_utils.getScopeHash)(scope).toString()}`,
+            received: `Scope: ${(0, import_utils.getSubscopeFromOuterProof)(proofData).toString()}`,
+            message: "The proof uses a different scope than the one expected"
+          };
+        }
+        if (!!committedInputs?.compare_age) {
+          const ageCommittedInputs = committedInputs?.compare_age;
+          const ageParameterCommitment = isForEVM ? await (0, import_utils.getAgeEVMParameterCommitment)(
+            ageCommittedInputs.currentDate,
+            ageCommittedInputs.minAge,
+            ageCommittedInputs.maxAge
+          ) : await (0, import_utils.getAgeParameterCommitment)(
+            ageCommittedInputs.currentDate,
+            ageCommittedInputs.minAge,
+            ageCommittedInputs.maxAge
+          );
+          if (!paramCommitments.includes(ageParameterCommitment)) {
+            console.warn("This proof does not verify the age");
+            isCorrect = false;
+            queryResultErrors.age.commitment = {
+              expected: `Age parameter commitment: ${ageParameterCommitment.toString()}`,
+              received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
+              message: "This proof does not verify the age"
+            };
+          }
+          const { isCorrect: isCorrectAge, queryResultErrors: queryResultErrorsAge } = this.checkAgePublicInputs(proof, queryResult);
+          isCorrect = isCorrect && isCorrectAge;
+          queryResultErrors = {
+            ...queryResultErrors,
+            ...queryResultErrorsAge
+          };
+        } else if (!!committedInputs?.compare_birthdate) {
+          const birthdateCommittedInputs = committedInputs?.compare_birthdate;
+          const birthdateParameterCommitment = isForEVM ? await (0, import_utils.getDateEVMParameterCommitment)(
+            import_utils.ProofType.BIRTHDATE,
+            birthdateCommittedInputs.currentDate,
+            birthdateCommittedInputs.minDate,
+            birthdateCommittedInputs.maxDate
+          ) : await (0, import_utils.getDateParameterCommitment)(
+            import_utils.ProofType.BIRTHDATE,
+            birthdateCommittedInputs.currentDate,
+            birthdateCommittedInputs.minDate,
+            birthdateCommittedInputs.maxDate
+          );
+          if (!paramCommitments.includes(birthdateParameterCommitment)) {
+            console.warn("This proof does not verify the birthdate");
+            isCorrect = false;
+            queryResultErrors.birthdate.commitment = {
+              expected: `Birthdate parameter commitment: ${birthdateParameterCommitment.toString()}`,
+              received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
+              message: "This proof does not verify the birthdate"
+            };
+          }
+          const { isCorrect: isCorrectBirthdate, queryResultErrors: queryResultErrorsBirthdate } = this.checkBirthdatePublicInputs(proof, queryResult);
+          isCorrect = isCorrect && isCorrectBirthdate;
+          queryResultErrors = {
+            ...queryResultErrors,
+            ...queryResultErrorsBirthdate
+          };
+        } else if (!!committedInputs?.compare_expiry) {
+          const expiryCommittedInputs = committedInputs?.compare_expiry;
+          const expiryParameterCommitment = isForEVM ? await (0, import_utils.getDateEVMParameterCommitment)(
+            import_utils.ProofType.EXPIRY_DATE,
+            expiryCommittedInputs.currentDate,
+            expiryCommittedInputs.minDate,
+            expiryCommittedInputs.maxDate
+          ) : await (0, import_utils.getDateParameterCommitment)(
+            import_utils.ProofType.EXPIRY_DATE,
+            expiryCommittedInputs.currentDate,
+            expiryCommittedInputs.minDate,
+            expiryCommittedInputs.maxDate
+          );
+          if (!paramCommitments.includes(expiryParameterCommitment)) {
+            console.warn("This proof does not verify the expiry date");
+            isCorrect = false;
+            queryResultErrors.expiry_date.commitment = {
+              expected: `Expiry date parameter commitment: ${expiryParameterCommitment.toString()}`,
+              received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
+              message: "This proof does not verify the expiry date"
+            };
+          }
+          const { isCorrect: isCorrectExpiryDate, queryResultErrors: queryResultErrorsExpiryDate } = this.checkExpiryDatePublicInputs(proof, queryResult);
+          isCorrect = isCorrect && isCorrectExpiryDate;
+          queryResultErrors = {
+            ...queryResultErrors,
+            ...queryResultErrorsExpiryDate
+          };
+        } else if (!!committedInputs?.disclose_bytes) {
+          const discloseCommittedInputs = committedInputs?.disclose_bytes;
+          const discloseParameterCommitment = isForEVM ? await (0, import_utils.getDiscloseEVMParameterCommitment)(
+            discloseCommittedInputs.discloseMask,
+            discloseCommittedInputs.disclosedBytes
+          ) : await (0, import_utils.getDiscloseParameterCommitment)(
+            discloseCommittedInputs.discloseMask,
+            discloseCommittedInputs.disclosedBytes
+          );
+          if (!paramCommitments.includes(discloseParameterCommitment)) {
+            console.warn("This proof does not verify any of the data disclosed");
+            isCorrect = false;
+            queryResultErrors.disclose.commitment = {
+              expected: `Disclosure parameter commitment: ${discloseParameterCommitment.toString()}`,
+              received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
+              message: "This proof does not verify any of the data disclosed"
+            };
+          }
+          const { isCorrect: isCorrectDisclose, queryResultErrors: queryResultErrorsDisclose } = this.checkDiscloseBytesPublicInputs(proof, queryResult);
+          isCorrect = isCorrect && isCorrectDisclose;
+          queryResultErrors = {
+            ...queryResultErrors,
+            ...queryResultErrorsDisclose
+          };
+        } else if (!!committedInputs?.inclusion_check_nationality) {
+          const inclusionCheckNationalityCommittedInputs = committedInputs?.inclusion_check_nationality;
+          const inclusionCheckNationalityParameterCommitment = isForEVM ? await (0, import_utils.getCountryEVMParameterCommitment)(
+            import_utils.ProofType.NATIONALITY_INCLUSION,
+            inclusionCheckNationalityCommittedInputs.countries
+          ) : await (0, import_utils.getCountryParameterCommitment)(
+            import_utils.ProofType.NATIONALITY_INCLUSION,
+            inclusionCheckNationalityCommittedInputs.countries
+          );
+          if (!paramCommitments.includes(inclusionCheckNationalityParameterCommitment)) {
+            console.warn("This proof does not verify the inclusion of the nationality");
+            isCorrect = false;
+            queryResultErrors.nationality.commitment = {
+              expected: `Nationality parameter commitment: ${inclusionCheckNationalityParameterCommitment.toString()}`,
+              received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
+              message: "This proof does not verify the inclusion of the nationality"
+            };
+          }
+          const countryList = inclusionCheckNationalityCommittedInputs.countries;
+          const {
+            isCorrect: isCorrectNationalityInclusion,
+            queryResultErrors: queryResultErrorsNationalityInclusion
+          } = this.checkNationalityInclusionPublicInputs(queryResult, countryList);
+          isCorrect = isCorrect && isCorrectNationalityInclusion;
+          queryResultErrors = {
+            ...queryResultErrors,
+            ...queryResultErrorsNationalityInclusion
+          };
+        } else if (!!committedInputs?.inclusion_check_issuing_country) {
+          const inclusionCheckIssuingCountryCommittedInputs = committedInputs?.inclusion_check_issuing_country;
+          const inclusionCheckIssuingCountryParameterCommitment = isForEVM ? await (0, import_utils.getCountryEVMParameterCommitment)(
+            import_utils.ProofType.ISSUING_COUNTRY_INCLUSION,
+            inclusionCheckIssuingCountryCommittedInputs.countries
+          ) : await (0, import_utils.getCountryParameterCommitment)(
+            import_utils.ProofType.ISSUING_COUNTRY_INCLUSION,
+            inclusionCheckIssuingCountryCommittedInputs.countries
+          );
+          if (!paramCommitments.includes(inclusionCheckIssuingCountryParameterCommitment)) {
+            console.warn("This proof does not verify the inclusion of the issuing country");
+            isCorrect = false;
+            queryResultErrors.issuing_country.commitment = {
+              expected: `Issuing country parameter commitment: ${inclusionCheckIssuingCountryParameterCommitment.toString()}`,
+              received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
+              message: "This proof does not verify the inclusion of the issuing country"
+            };
+          }
+          const countryList = inclusionCheckIssuingCountryCommittedInputs.countries;
+          const {
+            isCorrect: isCorrectIssuingCountryInclusion,
+            queryResultErrors: queryResultErrorsIssuingCountryInclusion
+          } = this.checkIssuingCountryInclusionPublicInputs(queryResult, countryList);
+          isCorrect = isCorrect && isCorrectIssuingCountryInclusion;
+          queryResultErrors = {
+            ...queryResultErrors,
+            ...queryResultErrorsIssuingCountryInclusion
+          };
+        } else if (!!committedInputs?.exclusion_check_nationality) {
+          const exclusionCheckNationalityCommittedInputs = committedInputs?.exclusion_check_nationality;
+          const exclusionCheckNationalityParameterCommitment = isForEVM ? await (0, import_utils.getCountryEVMParameterCommitment)(
+            import_utils.ProofType.NATIONALITY_EXCLUSION,
+            exclusionCheckNationalityCommittedInputs.countries
+          ) : await (0, import_utils.getCountryParameterCommitment)(
+            import_utils.ProofType.NATIONALITY_EXCLUSION,
+            exclusionCheckNationalityCommittedInputs.countries
+          );
+          if (!paramCommitments.includes(exclusionCheckNationalityParameterCommitment)) {
+            console.warn("This proof does not verify the exclusion of the nationality");
+            isCorrect = false;
+            queryResultErrors.nationality.commitment = {
+              expected: `Nationality parameter commitment: ${exclusionCheckNationalityParameterCommitment.toString()}`,
+              received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
+              message: "This proof does not verify the exclusion of the nationality"
+            };
+          }
+          const countryList = exclusionCheckNationalityCommittedInputs.countries;
+          const {
+            isCorrect: isCorrectNationalityExclusion,
+            queryResultErrors: queryResultErrorsNationalityExclusion
+          } = this.checkNationalityExclusionPublicInputs(queryResult, countryList);
+          isCorrect = isCorrect && isCorrectNationalityExclusion;
+          queryResultErrors = {
+            ...queryResultErrors,
+            ...queryResultErrorsNationalityExclusion
+          };
+        } else if (!!committedInputs?.exclusion_check_issuing_country) {
+          const exclusionCheckIssuingCountryCommittedInputs = committedInputs?.exclusion_check_issuing_country;
+          const exclusionCheckIssuingCountryParameterCommitment = isForEVM ? await (0, import_utils.getCountryEVMParameterCommitment)(
+            import_utils.ProofType.ISSUING_COUNTRY_EXCLUSION,
+            exclusionCheckIssuingCountryCommittedInputs.countries
+          ) : await (0, import_utils.getCountryParameterCommitment)(
+            import_utils.ProofType.ISSUING_COUNTRY_EXCLUSION,
+            exclusionCheckIssuingCountryCommittedInputs.countries
+          );
+          if (!paramCommitments.includes(exclusionCheckIssuingCountryParameterCommitment)) {
+            console.warn("This proof does not verify the exclusion of the issuing country");
+            isCorrect = false;
+            queryResultErrors.issuing_country.commitment = {
+              expected: `Issuing country parameter commitment: ${exclusionCheckIssuingCountryParameterCommitment.toString()}`,
+              received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
+              message: "This proof does not verify the exclusion of the issuing country"
+            };
+          }
+          const countryList = exclusionCheckIssuingCountryCommittedInputs.countries;
+          const {
+            isCorrect: isCorrectIssuingCountryExclusion,
+            queryResultErrors: queryResultErrorsIssuingCountryExclusion
+          } = this.checkIssuingCountryExclusionPublicInputs(queryResult, countryList);
+          isCorrect = isCorrect && isCorrectIssuingCountryExclusion;
+          queryResultErrors = {
+            ...queryResultErrors,
+            ...queryResultErrorsIssuingCountryExclusion
+          };
+        } else if (!!committedInputs?.bind) {
+          const bindCommittedInputs = committedInputs?.bind;
+          const bindParameterCommitment = isForEVM ? await (0, import_utils.getBindEVMParameterCommitment)((0, import_utils.formatBoundData)(bindCommittedInputs.data)) : await (0, import_utils.getBindParameterCommitment)((0, import_utils.formatBoundData)(bindCommittedInputs.data));
+          if (!paramCommitments.includes(bindParameterCommitment)) {
+            console.warn("This proof does not verify the bound data");
+            isCorrect = false;
+            queryResultErrors.bind.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
+          };
+        }
+        uniqueIdentifier = (0, import_utils.getNullifierFromOuterProof)(proofData).toString(10);
+      } 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.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.commitment = {
+            expected: `Commitment: ${commitmentOut?.toString() || "undefined"}`,
+            received: `Commitment: ${commitmentIn?.toString() || "undefined"}`,
+            message: "Failed to check the link between the ID signature and the data signed"
+          };
+        }
+        commitmentOut = (0, import_utils.getCommitmentOutFromIntegrityProof)(proofData);
+        const currentDate = (0, import_utils.getCurrentDateFromIntegrityProof)(proofData);
+        const todayToCurrentDate = today.getTime() - currentDate.getTime();
+        const differenceInDays = validity ?? 180;
+        const expectedDifference = differenceInDays * 864e5;
+        const actualDifference = today.getTime() - (today.getTime() - expectedDifference);
+        if (todayToCurrentDate >= actualDifference) {
+          console.warn(
+            `The date used to check the validity of the ID is older than ${differenceInDays} days. You can ask the user to rescan their ID or ask them to disclose their expiry date`
+          );
+          isCorrect = false;
+          queryResultErrors.data_check_integrity.date = {
+            expected: `Difference: ${differenceInDays} days`,
+            received: `Difference: ${Math.round(todayToCurrentDate / 864e5)} days`,
+            message: "The date used to check the validity of the ID is older than the validity period"
+          };
+        }
+      } 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.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.commitment = {
+            expected: `Commitment: ${calculatedParamCommitment}`,
+            received: `Commitment: ${paramCommitment}`,
+            message: "The disclosed data does not match the data committed by the proof"
+          };
+        }
+        const { isCorrect: isCorrectScope, queryResultErrors: queryResultErrorsScope } = this.checkScopeFromDisclosureProof(proofData, queryResultErrors, "disclose", scope);
+        isCorrect = isCorrect && isCorrectScope;
+        queryResultErrors = {
+          ...queryResultErrors,
+          ...queryResultErrorsScope
+        };
+        const { isCorrect: isCorrectDisclose, queryResultErrors: queryResultErrorsDisclose } = this.checkDiscloseBytesPublicInputs(proof, queryResult);
+        isCorrect = isCorrect && isCorrectDisclose && isCorrectScope;
+        queryResultErrors = {
+          ...queryResultErrors,
+          ...queryResultErrorsDisclose,
+          ...queryResultErrorsScope
+        };
+        uniqueIdentifier = (0, import_utils.getNullifierFromDisclosureProof)(proofData).toString(10);
+      } 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.commitment = {
+            expected: `Commitment: ${commitmentOut}`,
+            received: `Commitment: ${commitmentIn}`,
+            message: "Failed to check the link between the validity of the ID and the age derived from it"
+          };
+        }
+        const paramCommitment = (0, import_utils.getParameterCommitmentFromDisclosureProof)(proofData);
+        const committedInputs = proof.committedInputs?.compare_age;
+        const calculatedParamCommitment = await (0, import_utils.getAgeParameterCommitment)(
+          committedInputs.currentDate,
+          committedInputs.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.commitment = {
+            expected: `Commitment: ${calculatedParamCommitment}`,
+            received: `Commitment: ${paramCommitment}`,
+            message: "The conditions for the age check do not match the conditions checked by the proof"
+          };
+        }
+        const { isCorrect: isCorrectScope, queryResultErrors: queryResultErrorsScope } = this.checkScopeFromDisclosureProof(proofData, queryResultErrors, "age", scope);
+        const { isCorrect: isCorrectAge, queryResultErrors: queryResultErrorsAge } = this.checkAgePublicInputs(proof, queryResult);
+        isCorrect = isCorrect && isCorrectAge && isCorrectScope;
+        queryResultErrors = {
+          ...queryResultErrors,
+          ...queryResultErrorsAge,
+          ...queryResultErrorsScope
+        };
+        uniqueIdentifier = (0, import_utils.getNullifierFromDisclosureProof)(proofData).toString(10);
+      } 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.commitment = {
+            expected: `Commitment: ${commitmentOut}`,
+            received: `Commitment: ${commitmentIn}`,
+            message: "Failed to check the link between the validity of the ID and the birthdate derived from it"
+          };
+        }
+        const paramCommitment = (0, import_utils.getParameterCommitmentFromDisclosureProof)(proofData);
+        const committedInputs = proof.committedInputs?.compare_birthdate;
+        const calculatedParamCommitment = await (0, import_utils.getDateParameterCommitment)(
+          import_utils.ProofType.BIRTHDATE,
+          committedInputs.currentDate,
+          committedInputs.minDate,
+          committedInputs.maxDate
+        );
+        if (paramCommitment !== calculatedParamCommitment) {
+          console.warn(
+            "The conditions for the birthdate check do not match the conditions checked by the proof"
+          );
+          isCorrect = false;
+          queryResultErrors.birthdate.commitment = {
+            expected: `Commitment: ${calculatedParamCommitment}`,
+            received: `Commitment: ${paramCommitment}`,
+            message: "The conditions for the birthdate check do not match the conditions checked by the proof"
+          };
+        }
+        const { isCorrect: isCorrectScope, queryResultErrors: queryResultErrorsScope } = this.checkScopeFromDisclosureProof(proofData, queryResultErrors, "birthdate", scope);
+        const { isCorrect: isCorrectBirthdate, queryResultErrors: queryResultErrorsBirthdate } = this.checkBirthdatePublicInputs(proof, queryResult);
+        isCorrect = isCorrect && isCorrectBirthdate && isCorrectScope;
+        queryResultErrors = {
+          ...queryResultErrors,
+          ...queryResultErrorsBirthdate,
+          ...queryResultErrorsScope
+        };
+        uniqueIdentifier = (0, import_utils.getNullifierFromDisclosureProof)(proofData).toString(10);
+      } 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.commitment = {
+            expected: `Commitment: ${commitmentOut}`,
+            received: `Commitment: ${commitmentIn}`,
+            message: "Failed to check the link between the validity of the ID and its expiry date"
+          };
+        }
+        const paramCommitment = (0, import_utils.getParameterCommitmentFromDisclosureProof)(proofData);
+        const committedInputs = proof.committedInputs?.compare_expiry;
+        const calculatedParamCommitment = await (0, import_utils.getDateParameterCommitment)(
+          import_utils.ProofType.EXPIRY_DATE,
+          committedInputs.currentDate,
+          committedInputs.minDate,
+          committedInputs.maxDate
+        );
+        if (paramCommitment !== calculatedParamCommitment) {
+          console.warn(
+            "The conditions for the expiry date check do not match the conditions checked by the proof"
+          );
+          isCorrect = false;
+          queryResultErrors.expiry_date.commitment = {
+            expected: `Commitment: ${calculatedParamCommitment}`,
+            received: `Commitment: ${paramCommitment}`,
+            message: "The conditions for the expiry date check do not match the conditions checked by the proof"
+          };
+        }
+        const { isCorrect: isCorrectScope, queryResultErrors: queryResultErrorsScope } = this.checkScopeFromDisclosureProof(proofData, queryResultErrors, "expiry_date", scope);
+        const { isCorrect: isCorrectExpiryDate, queryResultErrors: queryResultErrorsExpiryDate } = this.checkExpiryDatePublicInputs(proof, queryResult);
+        isCorrect = isCorrect && isCorrectExpiryDate && isCorrectScope;
+        queryResultErrors = {
+          ...queryResultErrors,
+          ...queryResultErrorsExpiryDate,
+          ...queryResultErrorsScope
+        };
+        uniqueIdentifier = (0, import_utils.getNullifierFromDisclosureProof)(proofData).toString(10);
+      } 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.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.commitment = {
+            expected: `Commitment: ${calculatedParamCommitment}`,
+            received: `Commitment: ${paramCommittment}`,
+            message: "The committed country list for the exclusion check does not match the one from the proof"
+          };
+        }
+        const { isCorrect: isCorrectScope, queryResultErrors: queryResultErrorsScope } = this.checkScopeFromDisclosureProof(proofData, queryResultErrors, "nationality", scope);
+        const {
+          isCorrect: isCorrectNationalityExclusion,
+          queryResultErrors: queryResultErrorsNationalityExclusion
+        } = this.checkNationalityExclusionPublicInputs(queryResult, countryList);
+        isCorrect = isCorrect && isCorrectNationalityExclusion && isCorrectScope;
+        queryResultErrors = {
+          ...queryResultErrors,
+          ...queryResultErrorsNationalityExclusion,
+          ...queryResultErrorsScope
+        };
+        uniqueIdentifier = (0, import_utils.getNullifierFromDisclosureProof)(proofData).toString(10);
+      } 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.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.commitment = {
+            expected: `Commitment: ${calculatedParamCommitment}`,
+            received: `Commitment: ${paramCommittment}`,
+            message: "The committed country list for the issuing country exclusion check does not match the one from the proof"
+          };
+        }
+        const { isCorrect: isCorrectScope, queryResultErrors: queryResultErrorsScope } = this.checkScopeFromDisclosureProof(proofData, queryResultErrors, "nationality", scope);
+        const {
+          isCorrect: isCorrectIssuingCountryExclusion,
+          queryResultErrors: queryResultErrorsIssuingCountryExclusion
+        } = this.checkIssuingCountryExclusionPublicInputs(queryResult, countryList);
+        isCorrect = isCorrect && isCorrectIssuingCountryExclusion && isCorrectScope;
+        queryResultErrors = {
+          ...queryResultErrors,
+          ...queryResultErrorsIssuingCountryExclusion,
+          ...queryResultErrorsScope
+        };
+        uniqueIdentifier = (0, import_utils.getNullifierFromDisclosureProof)(proofData).toString(10);
+      } 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.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.commitment = {
+            expected: `Commitment: ${calculatedParamCommitment}`,
+            received: `Commitment: ${paramCommittment}`,
+            message: "The committed country list for the nationality inclusion check does not match the one from the proof"
+          };
+        }
+        const { isCorrect: isCorrectScope, queryResultErrors: queryResultErrorsScope } = this.checkScopeFromDisclosureProof(proofData, queryResultErrors, "nationality", scope);
+        const {
+          isCorrect: isCorrectNationalityInclusion,
+          queryResultErrors: queryResultErrorsNationalityInclusion
+        } = this.checkNationalityInclusionPublicInputs(queryResult, countryList);
+        isCorrect = isCorrect && isCorrectNationalityInclusion && isCorrectScope;
+        queryResultErrors = {
+          ...queryResultErrors,
+          ...queryResultErrorsNationalityInclusion,
+          ...queryResultErrorsScope
+        };
+        uniqueIdentifier = (0, import_utils.getNullifierFromDisclosureProof)(proofData).toString(10);
+      } 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.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.commitment = {
+            expected: `Commitment: ${calculatedParamCommitment}`,
+            received: `Commitment: ${paramCommittment}`,
+            message: "The committed country list for the issuing country inclusion check does not match the one from the proof"
+          };
+        }
+        const { isCorrect: isCorrectScope, queryResultErrors: queryResultErrorsScope } = this.checkScopeFromDisclosureProof(proofData, queryResultErrors, "nationality", scope);
+        const {
+          isCorrect: isCorrectIssuingCountryInclusion,
+          queryResultErrors: queryResultErrorsIssuingCountryInclusion
+        } = this.checkIssuingCountryInclusionPublicInputs(queryResult, countryList);
+        isCorrect = isCorrect && isCorrectIssuingCountryInclusion && isCorrectScope;
+        queryResultErrors = {
+          ...queryResultErrors,
+          ...queryResultErrorsIssuingCountryInclusion,
+          ...queryResultErrorsScope
+        };
+        uniqueIdentifier = (0, import_utils.getNullifierFromDisclosureProof)(proofData).toString(10);
+      } 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.commitment = {
+            expected: `Commitment: ${calculatedParamCommitment}`,
+            received: `Commitment: ${paramCommittment}`,
+            message: "The bound data does not match the one from the proof"
+          };
+        }
+        const { isCorrect: isCorrectBind, queryResultErrors: queryResultErrorsBind } = this.checkBindPublicInputs(queryResult, bindCommittedInputs.data);
+        isCorrect = isCorrect && isCorrectBind;
+        queryResultErrors = {
+          ...queryResultErrors,
+          ...queryResultErrorsBind
+        };
+        uniqueIdentifier = (0, import_utils.getNullifierFromDisclosureProof)(proofData).toString(10);
+      }
+    }
+    return { isCorrect, uniqueIdentifier, queryResultErrors };
+  }
+  /**
+   * @notice Verify the proofs received from the mobile app.
+   * @param proofs The proofs to verify.
+   * @param queryResult The query result to verify against
+   * @param validity How many days ago should have the ID been last scanned by the user?
+   * @param scope Scope this request to a specific use case
+   * @param evmChain The EVM chain to use for the verification (if using the proof onchain)
+   * @param devMode Whether to enable dev mode. This will allow you to verify mock proofs (i.e. from ZKR)
+   * @param writingDirectory The directory (e.g. `./tmp`) where the necessary temporary artifacts for verification are written to.
+   * It should only be needed when running the `verify` function on a server with restricted write access (e.g. Vercel)
+   * @returns An object containing the unique identifier associated to the user
+   * and a boolean indicating whether the proofs were successfully verified.
+   */
+  async verify({
+    proofs,
+    queryResult,
+    validity,
+    scope,
+    evmChain,
+    devMode = false,
+    writingDirectory
+  }) {
+    if (!proofs || proofs.length === 0) {
+      return {
+        uniqueIdentifier: void 0,
+        verified: false
+      };
+    }
+    const formattedResult = queryResult;
+    if (formattedResult.birthdate && formattedResult.birthdate.disclose) {
+      formattedResult.birthdate.disclose.result = new Date(
+        formattedResult.birthdate.disclose.result
+      );
+    }
+    if (formattedResult.expiry_date && formattedResult.expiry_date.disclose) {
+      formattedResult.expiry_date.disclose.result = new Date(
+        formattedResult.expiry_date.disclose.result
+      );
+    }
+    const { BarretenbergVerifier } = await import("@aztec/bb.js");
+    if (typeof window === "undefined" && !writingDirectory) {
+      writingDirectory = "/tmp";
+    }
+    const verifier = new BarretenbergVerifier({
+      crsPath: writingDirectory ? writingDirectory + "/.bb-crs" : void 0
+    });
+    let verified = true;
+    let uniqueIdentifier;
+    let queryResultErrors;
+    const chainId = evmChain ? getChainIdFromEVMChain(evmChain) : void 0;
+    const {
+      isCorrect,
+      uniqueIdentifier: uniqueIdentifierFromPublicInputs,
+      queryResultErrors: queryResultErrorsFromPublicInputs
+    } = await this.checkPublicInputs(proofs, formattedResult, validity, scope, chainId);
+    uniqueIdentifier = uniqueIdentifierFromPublicInputs;
+    verified = isCorrect;
+    queryResultErrors = isCorrect ? void 0 : queryResultErrorsFromPublicInputs;
+    if (uniqueIdentifier && (BigInt(uniqueIdentifier) === BigInt(1) || BigInt(uniqueIdentifier) === BigInt(0)) && !devMode) {
+      verified = false;
+      console.warn(
+        "You are trying to verify a mock proof. This is only allowed in dev mode. To enable dev mode, set the `devMode` parameter to `true` in the request function parameters."
+      );
+    }
+    if (verified) {
+      const registryClient = new import_registry.RegistryClient({ chainId: 11155111 });
+      const circuitManifest = await registryClient.getCircuitManifest(void 0, {
+        // We assume all proofs have the same version
+        version: proofs[0].version
+      });
+      for (const proof of proofs) {
+        const proofData = (0, import_utils.getProofData)(proof.proof, (0, import_utils.getNumberOfPublicInputs)(proof.name));
+        const hostedPackagedCircuit = await registryClient.getPackagedCircuit(
+          proof.name,
+          circuitManifest
+        );
+        if (proof.name?.startsWith("outer_evm")) {
+          try {
+            const { createPublicClient, http } = await import("viem");
+            const { sepolia } = await import("viem/chains");
+            const { address, abi, functionName } = this.getSolidityVerifierDetails("ethereum_sepolia");
+            const client = createPublicClient({
+              chain: sepolia,
+              transport: http("https://ethereum-sepolia-rpc.publicnode.com")
+            });
+            const params = this.getSolidityVerifierParameters({
+              proof,
+              validityPeriodInDays: validity,
+              domain: this.domain,
+              scope,
+              devMode
+            });
+            const result = await client.readContract({
+              address,
+              abi,
+              functionName,
+              args: [params]
+            });
+            const isVerified = Array.isArray(result) ? Boolean(result[0]) : false;
+            verified = isVerified;
+          } catch (error) {
+            console.warn("Error verifying proof", error);
+            verified = false;
+          }
+        } else {
+          const vkeyBytes = import_buffer.Buffer.from(hostedPackagedCircuit.vkey, "base64");
+          try {
+            verified = await verifier.verifyUltraHonkProof(
+              {
+                proof: import_buffer.Buffer.from(proofData.proof.join(""), "hex"),
+                publicInputs: proofData.publicInputs
+              },
+              new Uint8Array(vkeyBytes)
+            );
+          } catch (e) {
+            console.warn("Error verifying proof", e);
+            verified = false;
+          }
+        }
+        if (!verified) {
+          break;
+        }
+      }
+    }
+    uniqueIdentifier = verified ? uniqueIdentifier : void 0;
+    return { uniqueIdentifier, verified, queryResultErrors };
+  }
+  getSolidityVerifierDetails(network) {
+    const baseConfig = {
+      functionName: "verifyProof",
+      abi: ZKPassportVerifier_default.abi
+    };
+    if (network === "ethereum_sepolia") {
+      return {
+        ...baseConfig,
+        address: "0xDDeFf76024052D26B78A7Fac66FFbd6fbc5bd9Ad"
+      };
+    } else if (network === "local_anvil") {
+      return {
+        ...baseConfig,
+        address: "0x0"
+      };
+    }
+    throw new Error(`Unsupported network: ${network}`);
+  }
+  getSolidityVerifierParameters({
+    proof,
+    validityPeriodInDays = 7,
+    domain,
+    scope,
+    devMode = false
+  }) {
+    if (!proof.name?.startsWith("outer_evm")) {
+      throw new Error(
+        "This proof cannot be verified on an EVM chain. Please make sure to use the `compressed-evm` mode."
+      );
+    }
+    const proofData = (0, import_utils.getProofData)(proof.proof, (0, import_utils.getNumberOfPublicInputs)(proof.name));
+    const actualProof = proofData.proof.slice(16);
+    const actualPublicInputs = proofData.publicInputs.concat(
+      proofData.proof.slice(0, 16).map((x) => `0x${x}`)
+    );
+    let committedInputCounts = [];
+    let committedInputs = [];
+    for (const key in proof.committedInputs) {
+      const committedInputCount = (0, import_utils.getCommittedInputCount)(key);
+      const circuitName = key;
+      committedInputCounts.push({ circuitName, count: committedInputCount });
+      let compressedCommittedInputs2 = "";
+      if (circuitName === "inclusion_check_issuing_country_evm" || circuitName === "inclusion_check_nationality_evm" || circuitName === "exclusion_check_issuing_country_evm" || circuitName === "exclusion_check_nationality_evm") {
+        const value = proof.committedInputs[circuitName];
+        const formattedCountries = value.countries;
+        if (circuitName === "exclusion_check_issuing_country_evm" || circuitName === "exclusion_check_nationality_evm") {
+          formattedCountries.sort((a, b) => a.localeCompare(b));
+        }
+        const proofType = (() => {
+          switch (circuitName) {
+            case "exclusion_check_issuing_country_evm":
+              return import_utils.ProofType.ISSUING_COUNTRY_EXCLUSION;
+            case "exclusion_check_nationality_evm":
+              return import_utils.ProofType.NATIONALITY_EXCLUSION;
+            case "inclusion_check_issuing_country_evm":
+              return import_utils.ProofType.ISSUING_COUNTRY_INCLUSION;
+            case "inclusion_check_nationality_evm":
+              return import_utils.ProofType.NATIONALITY_INCLUSION;
+          }
+        })();
+        compressedCommittedInputs2 = proofType.toString(16).padStart(2, "0") + (0, import_utils.rightPadArrayWithZeros)(
+          formattedCountries.map((c) => Array.from(new TextEncoder().encode(c))).flat(),
+          600
+        ).map((x) => x.toString(16).padStart(2, "0")).join("");
+      } else if (circuitName === "compare_age_evm") {
+        const value = proof.committedInputs[circuitName];
+        const currentDateBytes = Array.from(new TextEncoder().encode(value.currentDate));
+        compressedCommittedInputs2 = import_utils.ProofType.AGE.toString(16).padStart(2, "0") + currentDateBytes.map((x) => x.toString(16).padStart(2, "0")).join("") + value.minAge.toString(16).padStart(2, "0") + value.maxAge.toString(16).padStart(2, "0");
+      } else if (circuitName === "compare_birthdate_evm") {
+        const value = proof.committedInputs[circuitName];
+        const currentDateBytes = Array.from(new TextEncoder().encode(value.currentDate));
+        const minDateBytes = Array.from(new TextEncoder().encode(value.minDate));
+        const maxDateBytes = Array.from(new TextEncoder().encode(value.maxDate));
+        compressedCommittedInputs2 = import_utils.ProofType.BIRTHDATE.toString(16).padStart(2, "0") + currentDateBytes.map((x) => x.toString(16).padStart(2, "0")).join("") + minDateBytes.map((x) => x.toString(16).padStart(2, "0")).join("") + maxDateBytes.map((x) => x.toString(16).padStart(2, "0")).join("");
+      } else if (circuitName === "compare_expiry_evm") {
+        const value = proof.committedInputs[circuitName];
+        const currentDateBytes = Array.from(new TextEncoder().encode(value.currentDate));
+        const minDateBytes = Array.from(new TextEncoder().encode(value.minDate));
+        const maxDateBytes = Array.from(new TextEncoder().encode(value.maxDate));
+        compressedCommittedInputs2 = import_utils.ProofType.EXPIRY_DATE.toString(16).padStart(2, "0") + currentDateBytes.map((x) => x.toString(16).padStart(2, "0")).join("") + minDateBytes.map((x) => x.toString(16).padStart(2, "0")).join("") + maxDateBytes.map((x) => x.toString(16).padStart(2, "0")).join("");
+      } else if (circuitName === "disclose_bytes_evm") {
+        const value = proof.committedInputs[circuitName];
+        compressedCommittedInputs2 = import_utils.ProofType.DISCLOSE.toString(16).padStart(2, "0") + value.discloseMask.map((x) => x.toString(16).padStart(2, "0")).join("") + value.disclosedBytes.map((x) => x.toString(16).padStart(2, "0")).join("");
+      } else if (circuitName === "bind_evm") {
+        const value = proof.committedInputs[circuitName];
+        compressedCommittedInputs2 = import_utils.ProofType.BIND.toString(16).padStart(2, "0") + (0, import_utils.rightPadArrayWithZeros)((0, import_utils.formatBoundData)(value.data), 500).map((x) => x.toString(16).padStart(2, "0")).join("");
+      } else {
+        throw new Error(`Unsupported circuit for EVM verification: ${circuitName}`);
+      }
+      committedInputs.push({ circuitName, inputs: compressedCommittedInputs2 });
+    }
+    const parameterCommitments = proofData.publicInputs.slice(12, proofData.publicInputs.length - 1);
+    let compressedCommittedInputs = "";
+    let committedInputCountsArray = [];
+    for (const commitment of parameterCommitments) {
+      const committedInput = committedInputs.find((x) => {
+        const rawHashedInputs = (0, import_sha2.sha256)((0, import_utils3.hexToBytes)(x.inputs));
+        const hashedInputs = new Uint8Array(rawHashedInputs.length);
+        for (let i = 0; i < rawHashedInputs.length - 1; i++) {
+          hashedInputs[i + 1] = rawHashedInputs[i];
+        }
+        hashedInputs[0] = 0;
+        return (0, import_utils2.bytesToHex)(hashedInputs) === commitment.replace("0x", "");
+      });
+      if (committedInput) {
+        const count = committedInputCounts.find(
+          (x) => x.circuitName === committedInput.circuitName
+        )?.count;
+        if (count) {
+          committedInputCountsArray.push(count);
+          compressedCommittedInputs += committedInput.inputs;
+        } else {
+          throw new Error(`Unknown circuit name: ${committedInput.circuitName}`);
+        }
+      } else {
+        throw new Error(`Invalid commitment: ${commitment}`);
+      }
+    }
+    const params = {
+      // Make sure the vkeyHash is 32 bytes
+      vkeyHash: `0x${proof.vkeyHash.replace("0x", "").padStart(64, "0")}`,
+      proof: `0x${actualProof.join("")}`,
+      publicInputs: actualPublicInputs,
+      committedInputs: `0x${compressedCommittedInputs}`,
+      committedInputCounts: committedInputCountsArray,
+      validityPeriodInDays,
+      domain: domain ?? this.domain,
+      scope: scope ?? "",
+      devMode
+    };
+    return params;
+  }
+  _getUrl(requestId) {
+    const base64Config = import_buffer.Buffer.from(JSON.stringify(this.topicToConfig[requestId])).toString(
+      "base64"
+    );
+    const base64Service = import_buffer.Buffer.from(JSON.stringify(this.topicToService[requestId])).toString(
+      "base64"
+    );
+    const pubkey = this.topicToPublicKey[requestId];
+    return `https://zkpassport.id/r?d=${this.domain}&t=${requestId}&c=${base64Config}&s=${base64Service}&p=${pubkey}&m=${this.topicToLocalConfig[requestId].mode}&v=${VERSION}`;
+  }
+  /**
+   * @notice Returns the URL of the request.
+   * @param requestId The request ID.
+   * @returns The URL of the request.
+   */
+  getUrl(requestId) {
+    return this._getUrl(requestId);
+  }
+  /**
+   * @notice Cancels a request by closing the WebSocket connection and deleting the associated data.
+   * @param requestId The request ID.
+   */
+  cancelRequest(requestId) {
+    if (this.topicToBridge[requestId]) {
+      this.topicToBridge[requestId].close();
+      delete this.topicToBridge[requestId];
+    }
+    delete this.topicToPublicKey[requestId];
+    delete this.topicToConfig[requestId];
+    delete this.topicToLocalConfig[requestId];
+    delete this.topicToProofs[requestId];
+    delete this.topicToExpectedProofCount[requestId];
+    delete this.topicToFailedProofCount[requestId];
+    delete this.topicToResults[requestId];
+    this.onRequestReceivedCallbacks[requestId] = [];
+    this.onGeneratingProofCallbacks[requestId] = [];
+    this.onBridgeConnectCallbacks[requestId] = [];
+    this.onProofGeneratedCallbacks[requestId] = [];
+    this.onRejectCallbacks[requestId] = [];
+    this.onErrorCallbacks[requestId] = [];
+  }
+  /**
+   * @notice Clears all requests.
+   */
+  clearAllRequests() {
+    for (const requestId in this.topicToBridge) {
+      this.cancelRequest(requestId);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ASEAN_COUNTRIES,
+  EEA_COUNTRIES,
+  EU_COUNTRIES,
+  MERCOSUR_COUNTRIES,
+  SANCTIONED_COUNTRIES,
+  SCHENGEN_COUNTRIES,
+  ZKPassport
+});