@zkpassport/sdk 0.2.15 → 0.3.1

package/dist/cjs/index.js

@@ -13,6 +13,10 @@ const logger_1 = require("./logger");
 const pako_1 = require("pako");
 const en_json_1 = tslib_1.__importDefault(require("i18n-iso-countries/langs/en.json"));
 const buffer_1 = require("buffer/");
+const sha256_1 = require("@noble/hashes/sha256");
+const utils_3 = require("@noble/hashes/utils");
+const ZKPassportVerifier_json_1 = tslib_1.__importDefault(require("./assets/abi/ZKPassportVerifier.json"));
+const DEFAULT_DATE_VALUE = new Date(1111, 10, 11);
 // If Buffer is not defined, then we use the Buffer from the buffer package
 if (typeof globalThis.Buffer === "undefined") {
     globalThis.Buffer = buffer_1.Buffer;
@@ -59,13 +63,13 @@ function generalCompare(fnName, key, value, requestId, requestIdToConfig) {
         [fnName]: value,
     };
 }
-var utils_3 = require("@zkpassport/utils");
-Object.defineProperty(exports, "SANCTIONED_COUNTRIES", { enumerable: true, get: function () { return utils_3.SANCTIONED_COUNTRIES; } });
-Object.defineProperty(exports, "EU_COUNTRIES", { enumerable: true, get: function () { return utils_3.EU_COUNTRIES; } });
-Object.defineProperty(exports, "EEA_COUNTRIES", { enumerable: true, get: function () { return utils_3.EEA_COUNTRIES; } });
-Object.defineProperty(exports, "SCHENGEN_COUNTRIES", { enumerable: true, get: function () { return utils_3.SCHENGEN_COUNTRIES; } });
-Object.defineProperty(exports, "ASEAN_COUNTRIES", { enumerable: true, get: function () { return utils_3.ASEAN_COUNTRIES; } });
-Object.defineProperty(exports, "MERCOSUR_COUNTRIES", { enumerable: true, get: function () { return utils_3.MERCOSUR_COUNTRIES; } });
+var utils_4 = require("@zkpassport/utils");
+Object.defineProperty(exports, "SANCTIONED_COUNTRIES", { enumerable: true, get: function () { return utils_4.SANCTIONED_COUNTRIES; } });
+Object.defineProperty(exports, "EU_COUNTRIES", { enumerable: true, get: function () { return utils_4.EU_COUNTRIES; } });
+Object.defineProperty(exports, "EEA_COUNTRIES", { enumerable: true, get: function () { return utils_4.EEA_COUNTRIES; } });
+Object.defineProperty(exports, "SCHENGEN_COUNTRIES", { enumerable: true, get: function () { return utils_4.SCHENGEN_COUNTRIES; } });
+Object.defineProperty(exports, "ASEAN_COUNTRIES", { enumerable: true, get: function () { return utils_4.ASEAN_COUNTRIES; } });
+Object.defineProperty(exports, "MERCOSUR_COUNTRIES", { enumerable: true, get: function () { return utils_4.MERCOSUR_COUNTRIES; } });
 class ZKPassport {
     //private wasmVerifierInit: boolean = false
     constructor(_domain) {
@@ -101,6 +105,7 @@ class ZKPassport {
             proofs: this.topicToProofs[topic],
             queryResult: result,
             validity: this.topicToLocalConfig[topic]?.validity,
+            scope: this.topicToService[topic]?.scope,
         });
         delete this.topicToProofs[topic];
         const hasFailedProofs = this.topicToFailedProofCount[topic] > 0;
@@ -117,6 +122,11 @@ class ZKPassport {
         delete this.topicToFailedProofCount[topic];
     }
     setExpectedProofCount(topic) {
+        // If the mode is not fast, we'll receive only 1 compressed proof
+        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 = [];
         // Determine which circuits are needed based on the requested fields
@@ -196,7 +206,13 @@ class ZKPassport {
             logger_1.noLogger.debug(`User generated proof`);
             // Uncompress the proof and convert it to a hex string
             const bytesProof = buffer_1.Buffer.from(request.params.proof, "base64");
+            const bytesCommittedInputs = request.params.committedInputs
+                ? buffer_1.Buffer.from(request.params.committedInputs, "base64")
+                : null;
             const uncompressedProof = (0, pako_1.inflate)(bytesProof);
+            const uncompressedCommittedInputs = bytesCommittedInputs
+                ? (0, pako_1.inflate)(bytesCommittedInputs)
+                : null;
             // The gzip lib in the app compress the proof as ASCII
             // and since the app passes the proof as a hex string, we can
             // just decode the bytes as hex characters using the TextDecoder
@@ -206,6 +222,9 @@ class ZKPassport {
                 vkeyHash: request.params.vkeyHash,
                 name: request.params.name,
                 version: request.params.version,
+                committedInputs: uncompressedCommittedInputs
+                    ? JSON.parse(new TextDecoder().decode(uncompressedCommittedInputs))
+                    : undefined,
             };
             this.topicToProofs[topic].push(processedProof);
             await Promise.all(this.onProofGeneratedCallbacks[topic].map((callback) => callback(processedProof)));
@@ -311,7 +330,7 @@ class ZKPassport {
                 const pubkey = (0, utils_2.bytesToHex)(this.topicToKeyPair[topic].publicKey);
                 this.setExpectedProofCount(topic);
                 return {
-                    url: `https://zkpassport.id/r?d=${this.domain}&t=${topic}&c=${base64Config}&s=${base64Service}&p=${pubkey}`,
+                    url: `https://zkpassport.id/r?d=${this.domain}&t=${topic}&c=${base64Config}&s=${base64Service}&p=${pubkey}&m=${this.topicToLocalConfig[topic].mode}`,
                     requestId: topic,
                     onRequestReceived: (callback) => this.onRequestReceivedCallbacks[topic].push(callback),
                     onGeneratingProof: (callback) => this.onGeneratingProofCallbacks[topic].push(callback),
@@ -335,7 +354,7 @@ class ZKPassport {
      * @param validity How many days ago should have the ID been last scanned by the user?
      * @returns The query builder object.
      */
-    async request({ name, logo, purpose, scope, validity, topicOverride, keyPairOverride, }) {
+    async request({ name, logo, purpose, scope, mode, validity, topicOverride, keyPairOverride, }) {
         const topic = topicOverride || (0, crypto_1.randomBytes)(16).toString("hex");
         const keyPair = keyPairOverride || (await (0, encryption_1.generateECDHKeyPair)());
         this.topicToKeyPair[topic] = {
@@ -349,6 +368,7 @@ class ZKPassport {
         this.topicToLocalConfig[topic] = {
             // Default to 6 months
             validity: validity || 6 * 30,
+            mode: mode || "fast",
         };
         this.onRequestReceivedCallbacks[topic] = [];
         this.onGeneratingProofCallbacks[topic] = [];
@@ -406,19 +426,319 @@ class ZKPassport {
         };
         return this.getZkPassportRequest(topic);
     }
-    async checkPublicInputs(proofs, queryResult, validity) {
-        let commitmentIn;
-        let commitmentOut;
+    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: {},
+        };
         let isCorrect = true;
-        let uniqueIdentifier;
-        const VALID_CERTIFICATE_REGISTRY_ROOT = [
-            BigInt("20192042006788880778219739574377003123593792072535937278552252195461520776494"),
-            BigInt("21301853597069384763054217328384418971999152625381818922211526730996340553696"),
-            BigInt("10839898448097753834842514286432152806152415606387598803678317315409344029817"),
-        ];
-        const defaultDateValue = new Date(1111, 10, 11);
-        const currentTime = new Date();
-        const today = new Date(currentTime.getFullYear(), currentTime.getMonth(), currentTime.getDate(), 0, 0, 0, 0);
+        // We can't be certain that the disclosed data is for a passport or an ID card
+        // so we need to check both (unless the document type is revealed)
+        const disclosedDataPassport = utils_1.DisclosedData.fromDisclosedBytes((proof.committedInputs?.disclose_bytes).disclosedBytes, "passport");
+        const disclosedDataIDCard = utils_1.DisclosedData.fromDisclosedBytes((proof.committedInputs?.disclose_bytes).disclosedBytes, "id_card");
+        if (queryResult.document_type) {
+            // Document type is always at the same index in the disclosed data
+            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, utils_1.formatName)(queryResult.fullname.eq.expected).toLowerCase() !==
+                    fullnamePassport.toLowerCase() &&
+                (0, utils_1.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, utils_1.formatName)(queryResult.fullname.disclose.result).toLowerCase() !==
+                    fullnamePassport.toLowerCase() &&
+                (0, utils_1.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) {
+            // If fullname was not revealed, then the name could be either the first name or last name
+            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, utils_1.formatName)(queryResult.firstname.eq.expected).toLowerCase() !==
+                    firstnamePassport.toLowerCase() &&
+                (0, utils_1.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, utils_1.formatName)(queryResult.firstname.disclose.result).toLowerCase() !==
+                    firstnamePassport.toLowerCase() &&
+                (0, utils_1.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) {
+            // If fullname was not revealed, then the name could be either the first name or last name
+            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, utils_1.formatName)(queryResult.lastname.eq.expected).toLowerCase() !==
+                    lastnamePassport.toLowerCase() &&
+                (0, utils_1.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, utils_1.formatName)(queryResult.lastname.disclose.result).toLowerCase() !==
+                    lastnamePassport.toLowerCase() &&
+                (0, utils_1.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: {},
@@ -435,388 +755,892 @@ class ZKPassport {
             lastname: {},
             fullname: {},
             document_number: {},
+            outer: {},
         };
-        // Since the order is important for the commitments, we need to sort the proofs
-        // by their expected order: root signature check -> ID signature check -> integrity check -> disclosure
-        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",
-            ];
-            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, utils_1.getProofData)(proof.proof, true);
-            if (proof.name?.startsWith("sig_check_dsc")) {
-                commitmentOut = (0, utils_1.getCommitmentFromDSCProof)(proofData);
-                const merkleRoot = (0, utils_1.getMerkleRootFromDSCProof)(proofData);
-                if (!VALID_CERTIFICATE_REGISTRY_ROOT.includes(merkleRoot)) {
-                    console.warn("The ID was signed by an unrecognized root certificate");
-                    isCorrect = false;
-                    queryResultErrors.sig_check_dsc.certificate = {
-                        expected: `Certificate registry root: ${VALID_CERTIFICATE_REGISTRY_ROOT.join(", ")}`,
-                        received: `Certificate registry root: ${merkleRoot.toString()}`,
-                        message: "The ID was signed by an unrecognized root certificate",
-                    };
-                }
+        let isCorrect = true;
+        const currentTime = new Date();
+        const today = new Date(currentTime.getFullYear(), currentTime.getMonth(), currentTime.getDate(), 0, 0, 0, 0);
+        const minAge = (0, utils_1.getMinAgeFromCommittedInputs)(proof.committedInputs?.compare_age);
+        const maxAge = (0, utils_1.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",
+                };
             }
-            else if (proof.name?.startsWith("sig_check_id_data")) {
-                commitmentIn = (0, utils_1.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, utils_1.getCommitmentOutFromIDDataProof)(proofData);
+            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",
+                };
             }
-            else if (proof.name?.startsWith("data_check_integrity")) {
-                commitmentIn = (0, utils_1.getCommitmentInFromIntegrityProof)(proofData);
-                if (commitmentIn !== commitmentOut) {
-                    console.warn("Failed to check the link between the ID signature and the data signed");
+            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.data_check_integrity.commitment = {
-                        expected: `Commitment: ${commitmentOut?.toString() || "undefined"}`,
-                        received: `Commitment: ${commitmentIn?.toString() || "undefined"}`,
-                        message: "Failed to check the link between the ID signature and the data signed",
+                    queryResultErrors.age.range = {
+                        expected: queryResult.age.range.expected,
+                        received: [minAge, maxAge],
+                        message: "Age is not in the expected range",
                     };
                 }
-                commitmentOut = (0, utils_1.getCommitmentOutFromIntegrityProof)(proofData);
-                const currentDate = (0, utils_1.getCurrentDateFromIntegrityProof)(proofData);
-                const todayToCurrentDate = today.getTime() - currentDate.getTime();
-                const differenceInDays = validity ?? 180;
-                const expectedDifference = differenceInDays * 86400000;
-                const actualDifference = today.getTime() - (today.getTime() - expectedDifference);
-                // The ID should not expire within the next 6 months (or whatever the custom value is)
-                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`);
+            }
+            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, utils_1.getCurrentDateFromCommittedInputs)(proof.committedInputs?.compare_age);
+        if (currentDate.getTime() !== today.getTime() &&
+            currentDate.getTime() !== today.getTime() - 86400000) {
+            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: {},
+        };
+        let isCorrect = true;
+        const currentTime = new Date();
+        const today = new Date(currentTime.getFullYear(), currentTime.getMonth(), currentTime.getDate(), 0, 0, 0);
+        const minDate = (0, utils_1.getMinDateFromCommittedInputs)(proof.committedInputs?.compare_birthdate);
+        const maxDate = (0, utils_1.getMaxDateFromCommittedInputs)(proof.committedInputs?.compare_birthdate);
+        const currentDate = (0, utils_1.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.data_check_integrity.date = {
-                        expected: `Difference: ${differenceInDays} days`,
-                        received: `Difference: ${Math.round(todayToCurrentDate / 86400000)} days`,
-                        message: "The date used to check the validity of the ID is older than the validity period",
+                    queryResultErrors.birthdate.range = {
+                        expected: queryResult.birthdate.range.expected,
+                        received: [minDate, maxDate],
+                        message: "Birthdate is not in the expected range",
                     };
                 }
             }
-            else if (proof.name === "disclose_bytes") {
-                commitmentIn = (0, utils_1.getCommitmentInFromDisclosureProof)(proofData);
-                if (commitmentIn !== commitmentOut) {
-                    console.warn("Failed to check the link between the validity of the ID and the data to disclose");
+            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() - 86400000) {
+            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: {},
+        };
+        let isCorrect = true;
+        const currentTime = new Date();
+        const today = new Date(currentTime.getFullYear(), currentTime.getMonth(), currentTime.getDate(), 0, 0, 0);
+        const minDate = (0, utils_1.getMinDateFromCommittedInputs)(proof.committedInputs?.compare_expiry);
+        const maxDate = (0, utils_1.getMaxDateFromCommittedInputs)(proof.committedInputs?.compare_expiry);
+        const currentDate = (0, utils_1.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.disclose.commitment = {
-                        expected: `Commitment: ${commitmentOut?.toString() || "undefined"}`,
-                        received: `Commitment: ${commitmentIn?.toString() || "undefined"}`,
-                        message: "Failed to check the link between the validity of the ID and the data to disclose",
+                    queryResultErrors.expiry_date.range = {
+                        expected: queryResult.expiry_date.range.expected,
+                        received: [minDate, maxDate],
+                        message: "Expiry date is not in the expected range",
                     };
                 }
-                // We can't be certain that the disclosed data is for a passport or an ID card
-                // so we need to check both (unless the document type is revealed)
-                const disclosedDataPassport = utils_1.DisclosedData.fromBytesProof(proofData, "passport");
-                const disclosedDataIDCard = utils_1.DisclosedData.fromBytesProof(proofData, "id_card");
-                if (queryResult.document_type) {
-                    // Document type is always at the same index in the disclosed data
-                    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.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() - 86400000) {
+            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: {},
+        };
+        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",
+            };
+        }
+        // Check the countryList is in ascending order
+        // If the prover doesn't use a sorted list then the proof cannot be trusted
+        // as it is requirement in the circuit for the exclusion check to work
+        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: {},
+        };
+        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",
+            };
+        }
+        // Check the countryList is in ascending order
+        // If the prover doesn't use a sorted list then the proof cannot be trusted
+        // as it is requirement in the circuit for the exclusion check to work
+        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: {},
+        };
+        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: {},
+        };
+        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) {
+        let isCorrect = true;
+        if (this.domain && (0, utils_1.getScopeHash)(this.domain) !== 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, utils_1.getScopeHash)(this.domain).toString()}`,
+                received: `Scope: ${BigInt(proofData.publicInputs[1]).toString()}`,
+                message: "The proof comes from a different domain than the one expected",
+            };
+        }
+        if (scope && (0, utils_1.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, utils_1.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 checkPublicInputs(proofs, queryResult, validity, scope) {
+        let commitmentIn;
+        let commitmentOut;
+        let isCorrect = true;
+        let uniqueIdentifier;
+        const VALID_CERTIFICATE_REGISTRY_ROOT = [
+            BigInt("20192042006788880778219739574377003123593792072535937278552252195461520776494"),
+            BigInt("21301853597069384763054217328384418971999152625381818922211526730996340553696"),
+            BigInt("10839898448097753834842514286432152806152415606387598803678317315409344029817"),
+        ];
+        const currentTime = 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: {},
+        };
+        // Since the order is important for the commitments, we need to sort the proofs
+        // by their expected order: root signature check -> ID signature check -> integrity check -> disclosure
+        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",
+            ];
+            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, utils_1.getProofData)(proof.proof, (0, utils_1.getNumberOfPublicInputs)(proof.name));
+            if (proof.name?.startsWith("outer")) {
+                const isForEVM = proof.name?.startsWith("outer_evm");
+                const certificateRegistryRoot = (0, utils_1.getCertificateRegistryRootFromOuterProof)(proofData);
+                if (!VALID_CERTIFICATE_REGISTRY_ROOT.includes(certificateRegistryRoot)) {
+                    console.warn("The ID was signed by an unrecognized root certificate");
+                    isCorrect = false;
+                    queryResultErrors.outer.certificate = {
+                        expected: `Certificate registry root: ${VALID_CERTIFICATE_REGISTRY_ROOT.join(", ")}`,
+                        received: `Certificate registry root: ${certificateRegistryRoot.toString()}`,
+                        message: "The ID was signed by an unrecognized root certificate",
+                    };
                 }
-                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",
-                        };
-                    }
+                const currentDate = (0, utils_1.getCurrentDateFromOuterProof)(proofData);
+                const todayToCurrentDate = today.getTime() - currentDate.getTime();
+                const differenceInDays = validity ?? 180;
+                const expectedDifference = differenceInDays * 86400000;
+                const actualDifference = today.getTime() - (today.getTime() - expectedDifference);
+                // The ID should not expire within the next 6 months (or whatever the custom value is)
+                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 / 86400000)} days`,
+                        message: "The date used to check the validity of the ID is older than the validity period",
+                    };
+                }
+                const paramCommitments = (0, utils_1.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, utils_1.getScopeHash)(this.domain) !== (0, utils_1.getScopeFromOuterProof)(proofData)) {
+                    console.warn("The proof comes from a different domain than the one expected");
+                    isCorrect = false;
+                    queryResultErrors.outer.scope = {
+                        expected: `Scope: ${(0, utils_1.getScopeHash)(this.domain).toString()}`,
+                        received: `Scope: ${(0, utils_1.getScopeFromOuterProof)(proofData).toString()}`,
+                        message: "The proof comes from a different domain than the one expected",
+                    };
+                }
+                if (scope && (0, utils_1.getScopeHash)(scope) !== (0, utils_1.getSubscopeFromOuterProof)(proofData)) {
+                    console.warn("The proof uses a different scope than the one expected");
+                    isCorrect = false;
+                    queryResultErrors.outer.scope = {
+                        expected: `Scope: ${(0, utils_1.getScopeHash)(scope).toString()}`,
+                        received: `Scope: ${(0, utils_1.getSubscopeFromOuterProof)(proofData).toString()}`,
+                        message: "The proof uses a different scope than the one expected",
+                    };
                 }
-                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");
+                if (!!committedInputs?.compare_age) {
+                    const ageCommittedInputs = committedInputs?.compare_age;
+                    const ageParameterCommitment = isForEVM
+                        ? await (0, utils_1.getAgeEVMParameterCommitment)(ageCommittedInputs.currentDate, ageCommittedInputs.minAge, ageCommittedInputs.maxAge)
+                        : await (0, utils_1.getAgeParameterCommitment)(ageCommittedInputs.currentDate, ageCommittedInputs.minAge, ageCommittedInputs.maxAge);
+                    if (!paramCommitments.includes(ageParameterCommitment)) {
+                        console.warn("This proof does not verify the age");
                         isCorrect = false;
-                        queryResultErrors.issuing_country.eq = {
-                            expected: `${queryResult.issuing_country.eq.expected}`,
-                            received: `${issuingCountryPassport ?? issuingCountryIDCard}`,
-                            message: "Issuing country does not match the expected issuing country",
+                        queryResultErrors.age.commitment = {
+                            expected: `Age parameter commitment: ${ageParameterCommitment.toString()}`,
+                            received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
+                            message: "This proof does not verify the age",
                         };
                     }
-                    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");
+                    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, utils_1.getDateEVMParameterCommitment)(utils_1.ProofType.BIRTHDATE, birthdateCommittedInputs.currentDate, birthdateCommittedInputs.minDate, birthdateCommittedInputs.maxDate)
+                        : await (0, utils_1.getDateParameterCommitment)(utils_1.ProofType.BIRTHDATE, birthdateCommittedInputs.currentDate, birthdateCommittedInputs.minDate, birthdateCommittedInputs.maxDate);
+                    if (!paramCommitments.includes(birthdateParameterCommitment)) {
+                        console.warn("This proof does not verify the birthdate");
                         isCorrect = false;
-                        queryResultErrors.issuing_country.disclose = {
-                            expected: `${queryResult.issuing_country.disclose.result}`,
-                            received: `${issuingCountryPassport ?? issuingCountryIDCard}`,
-                            message: "Issuing country does not match the disclosed issuing country in query result",
+                        queryResultErrors.birthdate.commitment = {
+                            expected: `Birthdate parameter commitment: ${birthdateParameterCommitment.toString()}`,
+                            received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
+                            message: "This proof does not verify the birthdate",
                         };
                     }
+                    const { isCorrect: isCorrectBirthdate, queryResultErrors: queryResultErrorsBirthdate } = this.checkBirthdatePublicInputs(proof, queryResult);
+                    isCorrect = isCorrect && isCorrectBirthdate;
+                    queryResultErrors = {
+                        ...queryResultErrors,
+                        ...queryResultErrorsBirthdate,
+                    };
                 }
-                if (queryResult.fullname) {
-                    const fullnamePassport = disclosedDataPassport.name;
-                    const fullnameIDCard = disclosedDataIDCard.name;
-                    if (queryResult.fullname.eq &&
-                        queryResult.fullname.eq.result &&
-                        (0, utils_1.formatName)(queryResult.fullname.eq.expected).toLowerCase() !==
-                            fullnamePassport.toLowerCase() &&
-                        (0, utils_1.formatName)(queryResult.fullname.eq.expected).toLowerCase() !==
-                            fullnameIDCard.toLowerCase()) {
-                        console.warn("Fullname does not match the expected fullname");
+                else if (!!committedInputs?.compare_expiry) {
+                    const expiryCommittedInputs = committedInputs?.compare_expiry;
+                    const expiryParameterCommitment = isForEVM
+                        ? await (0, utils_1.getDateEVMParameterCommitment)(utils_1.ProofType.EXPIRY_DATE, expiryCommittedInputs.currentDate, expiryCommittedInputs.minDate, expiryCommittedInputs.maxDate)
+                        : await (0, utils_1.getDateParameterCommitment)(utils_1.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.fullname.eq = {
-                            expected: `${queryResult.fullname.eq.expected}`,
-                            received: `${fullnamePassport ?? fullnameIDCard}`,
-                            message: "Fullname does not match the expected fullname",
+                        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",
                         };
                     }
-                    if (queryResult.fullname.disclose &&
-                        (0, utils_1.formatName)(queryResult.fullname.disclose.result).toLowerCase() !==
-                            fullnamePassport.toLowerCase() &&
-                        (0, utils_1.formatName)(queryResult.fullname.disclose.result).toLowerCase() !==
-                            fullnameIDCard.toLowerCase()) {
-                        console.warn("Fullname does not match the disclosed fullname in query result");
+                    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, utils_1.getDiscloseEVMParameterCommitment)(discloseCommittedInputs.discloseMask, discloseCommittedInputs.disclosedBytes)
+                        : await (0, utils_1.getDiscloseParameterCommitment)(discloseCommittedInputs.discloseMask, discloseCommittedInputs.disclosedBytes);
+                    if (!paramCommitments.includes(discloseParameterCommitment)) {
+                        console.warn("This proof does not verify any of the data disclosed");
                         isCorrect = false;
-                        queryResultErrors.fullname.disclose = {
-                            expected: `${queryResult.fullname.disclose.result}`,
-                            received: `${fullnamePassport ?? fullnameIDCard}`,
-                            message: "Fullname does not match the disclosed fullname in query result",
+                        queryResultErrors.disclose.commitment = {
+                            expected: `Disclosure parameter commitment: ${discloseParameterCommitment.toString()}`,
+                            received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
+                            message: "This proof does not verify any of the data disclosed",
                         };
                     }
+                    const { isCorrect: isCorrectDisclose, queryResultErrors: queryResultErrorsDisclose } = this.checkDiscloseBytesPublicInputs(proof, queryResult);
+                    isCorrect = isCorrect && isCorrectDisclose;
+                    queryResultErrors = {
+                        ...queryResultErrors,
+                        ...queryResultErrorsDisclose,
+                    };
                 }
-                if (queryResult.firstname) {
-                    // If fullname was not revealed, then the name could be either the first name or last name
-                    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, utils_1.formatName)(queryResult.firstname.eq.expected).toLowerCase() !==
-                            firstnamePassport.toLowerCase() &&
-                        (0, utils_1.formatName)(queryResult.firstname.eq.expected).toLowerCase() !==
-                            firstnameIDCard.toLowerCase()) {
-                        console.warn("Firstname does not match the expected firstname");
+                else if (!!committedInputs?.inclusion_check_nationality) {
+                    const inclusionCheckNationalityCommittedInputs = committedInputs?.inclusion_check_nationality;
+                    const inclusionCheckNationalityParameterCommitment = isForEVM
+                        ? await (0, utils_1.getCountryEVMParameterCommitment)(utils_1.ProofType.NATIONALITY_INCLUSION, inclusionCheckNationalityCommittedInputs.countries)
+                        : await (0, utils_1.getCountryParameterCommitment)(utils_1.ProofType.NATIONALITY_INCLUSION, inclusionCheckNationalityCommittedInputs.countries);
+                    if (!paramCommitments.includes(inclusionCheckNationalityParameterCommitment)) {
+                        console.warn("This proof does not verify the inclusion of the nationality");
                         isCorrect = false;
-                        queryResultErrors.firstname.eq = {
-                            expected: `${queryResult.firstname.eq.expected}`,
-                            received: `${firstnamePassport ?? firstnameIDCard}`,
-                            message: "Firstname does not match the expected firstname",
+                        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",
                         };
                     }
-                    if (queryResult.firstname.disclose &&
-                        (0, utils_1.formatName)(queryResult.firstname.disclose.result).toLowerCase() !==
-                            firstnamePassport.toLowerCase() &&
-                        (0, utils_1.formatName)(queryResult.firstname.disclose.result).toLowerCase() !==
-                            firstnameIDCard.toLowerCase()) {
-                        console.warn("Firstname does not match the disclosed firstname in query result");
+                    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, utils_1.getCountryEVMParameterCommitment)(utils_1.ProofType.ISSUING_COUNTRY_INCLUSION, inclusionCheckIssuingCountryCommittedInputs.countries)
+                        : await (0, utils_1.getCountryParameterCommitment)(utils_1.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.firstname.disclose = {
-                            expected: `${queryResult.firstname.disclose.result}`,
-                            received: `${firstnamePassport ?? firstnameIDCard}`,
-                            message: "Firstname does not match the disclosed firstname in query result",
+                        queryResultErrors.issuing_country.commitment = {
+                            expected: `Issuing country parameter commitment: ${inclusionCheckIssuingCountryParameterCommitment.toString()}`,
+                            received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
+                            message: "This proof does not verify the inclusion of the issuing country",
                         };
                     }
+                    const countryList = inclusionCheckIssuingCountryCommittedInputs.countries;
+                    const { isCorrect: isCorrectIssuingCountryInclusion, queryResultErrors: queryResultErrorsIssuingCountryInclusion, } = this.checkIssuingCountryInclusionPublicInputs(queryResult, countryList);
+                    isCorrect = isCorrect && isCorrectIssuingCountryInclusion;
+                    queryResultErrors = {
+                        ...queryResultErrors,
+                        ...queryResultErrorsIssuingCountryInclusion,
+                    };
                 }
-                if (queryResult.lastname) {
-                    // If fullname was not revealed, then the name could be either the first name or last name
-                    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, utils_1.formatName)(queryResult.lastname.eq.expected).toLowerCase() !==
-                            lastnamePassport.toLowerCase() &&
-                        (0, utils_1.formatName)(queryResult.lastname.eq.expected).toLowerCase() !==
-                            lastnameIDCard.toLowerCase()) {
-                        console.warn("Lastname does not match the expected lastname");
+                else if (!!committedInputs?.exclusion_check_nationality) {
+                    const exclusionCheckNationalityCommittedInputs = committedInputs?.exclusion_check_nationality;
+                    const exclusionCheckNationalityParameterCommitment = isForEVM
+                        ? await (0, utils_1.getCountryEVMParameterCommitment)(utils_1.ProofType.NATIONALITY_EXCLUSION, exclusionCheckNationalityCommittedInputs.countries)
+                        : await (0, utils_1.getCountryParameterCommitment)(utils_1.ProofType.NATIONALITY_EXCLUSION, exclusionCheckNationalityCommittedInputs.countries);
+                    if (!paramCommitments.includes(exclusionCheckNationalityParameterCommitment)) {
+                        console.warn("This proof does not verify the exclusion of the nationality");
                         isCorrect = false;
-                        queryResultErrors.lastname.eq = {
-                            expected: `${queryResult.lastname.eq.expected}`,
-                            received: `${lastnamePassport ?? lastnameIDCard}`,
-                            message: "Lastname does not match the expected lastname",
+                        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",
                         };
                     }
-                    if (queryResult.lastname.disclose &&
-                        (0, utils_1.formatName)(queryResult.lastname.disclose.result).toLowerCase() !==
-                            lastnamePassport.toLowerCase() &&
-                        (0, utils_1.formatName)(queryResult.lastname.disclose.result).toLowerCase() !==
-                            lastnameIDCard.toLowerCase()) {
-                        console.warn("Lastname does not match the disclosed lastname in query result");
+                    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, utils_1.getCountryEVMParameterCommitment)(utils_1.ProofType.ISSUING_COUNTRY_EXCLUSION, exclusionCheckIssuingCountryCommittedInputs.countries)
+                        : await (0, utils_1.getCountryParameterCommitment)(utils_1.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.lastname.disclose = {
-                            expected: `${queryResult.lastname.disclose.result}`,
-                            received: `${lastnamePassport ?? lastnameIDCard}`,
-                            message: "Lastname does not match the disclosed lastname in query result",
+                        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,
+                    };
+                }
+                uniqueIdentifier = (0, utils_1.getNullifierFromOuterProof)(proofData).toString(10);
+            }
+            else if (proof.name?.startsWith("sig_check_dsc")) {
+                commitmentOut = (0, utils_1.getCommitmentFromDSCProof)(proofData);
+                const merkleRoot = (0, utils_1.getMerkleRootFromDSCProof)(proofData);
+                if (!VALID_CERTIFICATE_REGISTRY_ROOT.includes(merkleRoot)) {
+                    console.warn("The ID was signed by an unrecognized root certificate");
+                    isCorrect = false;
+                    queryResultErrors.sig_check_dsc.certificate = {
+                        expected: `Certificate registry root: ${VALID_CERTIFICATE_REGISTRY_ROOT.join(", ")}`,
+                        received: `Certificate registry root: ${merkleRoot.toString()}`,
+                        message: "The ID was signed by an unrecognized root certificate",
+                    };
+                }
+            }
+            else if (proof.name?.startsWith("sig_check_id_data")) {
+                commitmentIn = (0, utils_1.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, utils_1.getCommitmentOutFromIDDataProof)(proofData);
+            }
+            else if (proof.name?.startsWith("data_check_integrity")) {
+                commitmentIn = (0, utils_1.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, utils_1.getCommitmentOutFromIntegrityProof)(proofData);
+                const currentDate = (0, utils_1.getCurrentDateFromIntegrityProof)(proofData);
+                const todayToCurrentDate = today.getTime() - currentDate.getTime();
+                const differenceInDays = validity ?? 180;
+                const expectedDifference = differenceInDays * 86400000;
+                const actualDifference = today.getTime() - (today.getTime() - expectedDifference);
+                // The ID should not expire within the next 6 months (or whatever the custom value is)
+                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 / 86400000)} 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, utils_1.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, utils_1.getParameterCommitmentFromDisclosureProof)(proofData);
+                const calculatedParamCommitment = await (0, utils_1.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, utils_1.getNullifierFromDisclosureProof)(proofData).toString(10);
             }
             else if (proof.name === "compare_age") {
@@ -830,92 +1654,26 @@ class ZKPassport {
                         message: "Failed to check the link between the validity of the ID and the age derived from it",
                     };
                 }
-                const minAge = (0, utils_1.getMinAgeFromProof)(proofData);
-                const maxAge = (0, utils_1.getMaxAgeFromProof)(proofData);
-                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, utils_1.getCurrentDateFromAgeProof)(proofData);
-                if (currentDate.getTime() !== today.getTime() &&
-                    currentDate.getTime() !== today.getTime() - 86400000) {
-                    console.warn("Current date in the proof is too old");
+                const paramCommitment = (0, utils_1.getParameterCommitmentFromDisclosureProof)(proofData);
+                const committedInputs = proof.committedInputs?.compare_age;
+                const calculatedParamCommitment = await (0, utils_1.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.disclose = {
-                        expected: `${today.toISOString()}`,
-                        received: `${currentDate.toISOString()}`,
-                        message: "Current date in the proof is too old",
+                    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, utils_1.getNullifierFromDisclosureProof)(proofData).toString(10);
             }
             else if (proof.name === "compare_birthdate") {
@@ -929,74 +1687,26 @@ class ZKPassport {
                         message: "Failed to check the link between the validity of the ID and the birthdate derived from it",
                     };
                 }
-                const minDate = (0, utils_1.getMinDateFromProof)(proofData);
-                const maxDate = (0, utils_1.getMaxDateFromProof)(proofData);
-                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() != defaultDateValue.getTime()) {
-                        console.warn("Maximum birthdate should be equal to default date value");
-                        isCorrect = false;
-                        queryResultErrors.birthdate.disclose = {
-                            expected: `${defaultDateValue.toISOString()}`,
-                            received: `${maxDate.toISOString()}`,
-                            message: "Maximum birthdate should be equal to default date value",
-                        };
-                    }
-                    if (!queryResult.birthdate.gte &&
-                        !queryResult.birthdate.range &&
-                        minDate.getTime() != defaultDateValue.getTime()) {
-                        console.warn("Minimum birthdate should be equal to default date value");
-                        isCorrect = false;
-                        queryResultErrors.birthdate.disclose = {
-                            expected: `${defaultDateValue.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");
+                const paramCommitment = (0, utils_1.getParameterCommitmentFromDisclosureProof)(proofData);
+                const committedInputs = proof.committedInputs?.compare_birthdate;
+                const calculatedParamCommitment = await (0, utils_1.getDateParameterCommitment)(utils_1.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.disclose = {
-                        message: "Birthdate is not set in the query result",
+                    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, utils_1.getNullifierFromDisclosureProof)(proofData).toString(10);
             }
             else if (proof.name === "compare_expiry") {
@@ -1010,74 +1720,26 @@ class ZKPassport {
                         message: "Failed to check the link between the validity of the ID and its expiry date",
                     };
                 }
-                const minDate = (0, utils_1.getMinDateFromProof)(proofData);
-                const maxDate = (0, utils_1.getMaxDateFromProof)(proofData);
-                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() != defaultDateValue.getTime()) {
-                        console.warn("Maximum expiry date should be equal to default date value");
-                        isCorrect = false;
-                        queryResultErrors.expiry_date.disclose = {
-                            expected: `${defaultDateValue.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() != defaultDateValue.getTime()) {
-                        console.warn("Minimum expiry date should be equal to default date value");
-                        isCorrect = false;
-                        queryResultErrors.expiry_date.disclose = {
-                            expected: `${defaultDateValue.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");
+                const paramCommitment = (0, utils_1.getParameterCommitmentFromDisclosureProof)(proofData);
+                const committedInputs = proof.committedInputs?.compare_expiry;
+                const calculatedParamCommitment = await (0, utils_1.getDateParameterCommitment)(utils_1.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.disclose = {
-                        message: "Expiry date is not set in the query result",
+                    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, utils_1.getNullifierFromDisclosureProof)(proofData).toString(10);
             }
             else if (proof.name === "exclusion_check_nationality") {
@@ -1091,39 +1753,26 @@ class ZKPassport {
                         message: "Failed to check the link between the validity of the ID and the nationality exclusion check",
                     };
                 }
-                const countryList = (0, utils_1.getCountryListFromExclusionProof)(proofData);
-                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");
+                const countryList = (proof.committedInputs?.exclusion_check_nationality).countries;
+                const paramCommittment = (0, utils_1.getParameterCommitmentFromDisclosureProof)(proofData);
+                const calculatedParamCommitment = await (0, utils_1.getCountryParameterCommitment)(utils_1.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.out = {
-                        message: "Nationality exclusion is not set in the query result",
+                    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",
                     };
                 }
-                // Check the countryList is in ascending order
-                // If the prover doesn't use a sorted list then the proof cannot be trusted
-                // as it is requirement in the circuit for the exclusion check to work
-                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",
-                        };
-                    }
-                }
+                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, utils_1.getNullifierFromDisclosureProof)(proofData).toString(10);
             }
             else if (proof.name === "exclusion_check_issuing_country") {
@@ -1137,39 +1786,26 @@ class ZKPassport {
                         message: "Failed to check the link between the validity of the ID and the issuing country exclusion check",
                     };
                 }
-                const countryList = (0, utils_1.getCountryListFromExclusionProof)(proofData);
-                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");
+                const countryList = (proof.committedInputs?.exclusion_check_issuing_country).countries;
+                const paramCommittment = (0, utils_1.getParameterCommitmentFromDisclosureProof)(proofData);
+                const calculatedParamCommitment = await (0, utils_1.getCountryParameterCommitment)(utils_1.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.out = {
-                        message: "Issuing country exclusion is not set in the query result",
+                    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",
                     };
                 }
-                // Check the countryList is in ascending order
-                // If the prover doesn't use a sorted list then the proof cannot be trusted
-                // as it is requirement in the circuit for the exclusion check to work
-                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",
-                        };
-                    }
-                }
+                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, utils_1.getNullifierFromDisclosureProof)(proofData).toString(10);
             }
             else if (proof.name === "inclusion_check_nationality") {
@@ -1183,27 +1819,26 @@ class ZKPassport {
                         message: "Failed to check the link between the validity of the ID and the nationality inclusion check",
                     };
                 }
-                const countryList = (0, utils_1.getCountryListFromInclusionProof)(proofData);
-                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");
+                const countryList = (proof.committedInputs?.inclusion_check_nationality).countries;
+                const paramCommittment = (0, utils_1.getParameterCommitmentFromDisclosureProof)(proofData);
+                const calculatedParamCommitment = await (0, utils_1.getCountryParameterCommitment)(utils_1.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.in = {
-                        message: "Nationality inclusion is not set in the query result",
+                    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, utils_1.getNullifierFromDisclosureProof)(proofData).toString(10);
             }
             else if (proof.name === "inclusion_check_issuing_country") {
@@ -1217,27 +1852,26 @@ class ZKPassport {
                         message: "Failed to check the link between the validity of the ID and the issuing country inclusion check",
                     };
                 }
-                const countryList = (0, utils_1.getCountryListFromInclusionProof)(proofData);
-                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");
+                const countryList = (proof.committedInputs?.inclusion_check_issuing_country).countries;
+                const paramCommittment = (0, utils_1.getParameterCommitmentFromDisclosureProof)(proofData);
+                const calculatedParamCommitment = await (0, utils_1.getCountryParameterCommitment)(utils_1.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.in = {
-                        message: "Issuing country inclusion is not set in the query result",
+                    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, utils_1.getNullifierFromDisclosureProof)(proofData).toString(10);
             }
         }
@@ -1251,7 +1885,7 @@ class ZKPassport {
      * @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, }) {
+    async verify({ proofs, queryResult, validity, scope, }) {
         const formattedResult = queryResult;
         // Make sure to reconvert the dates to Date objects
         if (formattedResult.birthdate && formattedResult.birthdate.disclose) {
@@ -1265,22 +1899,56 @@ class ZKPassport {
         let verified = true;
         let uniqueIdentifier;
         let queryResultErrors;
-        const { isCorrect, uniqueIdentifier: uniqueIdentifierFromPublicInputs, queryResultErrors: queryResultErrorsFromPublicInputs, } = await this.checkPublicInputs(proofs, formattedResult, validity);
+        const { isCorrect, uniqueIdentifier: uniqueIdentifierFromPublicInputs, queryResultErrors: queryResultErrorsFromPublicInputs, } = await this.checkPublicInputs(proofs, formattedResult, validity, scope);
         uniqueIdentifier = uniqueIdentifierFromPublicInputs;
         verified = isCorrect;
         queryResultErrors = isCorrect ? undefined : queryResultErrorsFromPublicInputs;
         // Only proceed with the proof verification if the public inputs are correct
         if (verified) {
             for (const proof of proofs) {
-                const proofData = (0, utils_1.getProofData)(proof.proof, true);
+                const proofData = (0, utils_1.getProofData)(proof.proof, (0, utils_1.getNumberOfPublicInputs)(proof.name));
                 const hostedPackagedCircuit = await (0, utils_1.getHostedPackagedCircuitByName)(proof.version, proof.name);
-                const vkeyBytes = buffer_1.Buffer.from(hostedPackagedCircuit.vkey, "base64");
-                try {
-                    verified = await verifier.verifyUltraHonkProof(proofData, new Uint8Array(vkeyBytes));
+                if (proof.name?.startsWith("outer_evm")) {
+                    try {
+                        const { createPublicClient, http } = await Promise.resolve().then(() => tslib_1.__importStar(require("viem")));
+                        const { sepolia } = await Promise.resolve().then(() => tslib_1.__importStar(require("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,
+                        });
+                        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;
+                    }
                 }
-                catch (e) {
-                    console.warn("Error verifying proof", e);
-                    verified = false;
+                else {
+                    const vkeyBytes = buffer_1.Buffer.from(hostedPackagedCircuit.vkey, "base64");
+                    try {
+                        verified = await verifier.verifyUltraHonkProof({
+                            proof: buffer_1.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 the loop if the proof is not valid
@@ -1293,6 +1961,156 @@ class ZKPassport {
         uniqueIdentifier = verified ? uniqueIdentifier : undefined;
         return { uniqueIdentifier, verified, queryResultErrors };
     }
+    getSolidityVerifierDetails(network) {
+        const baseConfig = {
+            functionName: "verifyProof",
+            abi: ZKPassportVerifier_json_1.default.abi,
+        };
+        if (network === "ethereum_sepolia") {
+            return {
+                ...baseConfig,
+                address: "0x21E12Fa30a1F98699F242ac062Db4a8e7b344B5d",
+            };
+        }
+        else if (network === "local_anvil") {
+            return {
+                ...baseConfig,
+                address: "0x2279B7A0a67DB372996a5FaB50D91eAA73d2eBe6",
+            };
+        }
+        throw new Error(`Unsupported network: ${network}`);
+    }
+    getSolidityVerifierParameters({ proof, validityPeriodInDays = 7, domain, scope, }) {
+        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, utils_1.getProofData)(proof.proof, (0, utils_1.getNumberOfPublicInputs)(proof.name));
+        // For EVM optimised proofs, the first 16 bytes of the proof are the aggregation object
+        // and should be moved at the end of the public inputs
+        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, utils_1.getCommittedInputCount)(key);
+            const circuitName = key;
+            committedInputCounts.push({ circuitName, count: committedInputCount });
+            let compressedCommittedInputs = "";
+            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 utils_1.ProofType.ISSUING_COUNTRY_EXCLUSION;
+                        case "exclusion_check_nationality_evm":
+                            return utils_1.ProofType.NATIONALITY_EXCLUSION;
+                        case "inclusion_check_issuing_country_evm":
+                            return utils_1.ProofType.ISSUING_COUNTRY_INCLUSION;
+                        case "inclusion_check_nationality_evm":
+                            return utils_1.ProofType.NATIONALITY_INCLUSION;
+                    }
+                })();
+                compressedCommittedInputs =
+                    proofType.toString(16).padStart(2, "0") +
+                        (0, utils_1.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));
+                compressedCommittedInputs =
+                    utils_1.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));
+                compressedCommittedInputs =
+                    utils_1.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));
+                compressedCommittedInputs =
+                    utils_1.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];
+                compressedCommittedInputs =
+                    utils_1.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 {
+                throw new Error(`Unsupported circuit for EVM verification: ${circuitName}`);
+            }
+            committedInputs.push({ circuitName, inputs: compressedCommittedInputs });
+        }
+        const parameterCommitments = proofData.publicInputs.slice(11, proofData.publicInputs.length - 1);
+        let compressedCommittedInputs = "";
+        let committedInputCountsArray = [];
+        for (const commitment of parameterCommitments) {
+            const committedInput = committedInputs.find((x) => {
+                const rawHashedInputs = (0, sha256_1.sha256)((0, utils_3.hexToBytes)(x.inputs));
+                // Shift the hash 8 bits to the right (1 byte)
+                // as one byte is dropped in the circuit to fit in the 254-bit field size
+                const hashedInputs = new Uint8Array(rawHashedInputs.length);
+                // Move each byte 1 position to the right (shifting 8 bits)
+                for (let i = 0; i < rawHashedInputs.length - 1; i++) {
+                    hashedInputs[i + 1] = rawHashedInputs[i];
+                }
+                // First byte becomes 0 (since we're shifting right)
+                hashedInputs[0] = 0;
+                return (0, utils_2.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,
+            scope: domain ?? this.domain,
+            subscope: scope ?? "",
+        };
+        return params;
+    }
     /**
      * @notice Returns the URL of the request.
      * @param requestId The request ID.
@@ -1302,7 +2120,7 @@ class ZKPassport {
         const pubkey = (0, utils_2.bytesToHex)(this.topicToKeyPair[requestId].publicKey);
         const base64Config = buffer_1.Buffer.from(JSON.stringify(this.topicToConfig[requestId])).toString("base64");
         const base64Service = buffer_1.Buffer.from(JSON.stringify(this.topicToService[requestId])).toString("base64");
-        return `https://zkpassport.id/r?d=${this.domain}&t=${requestId}&c=${base64Config}&s=${base64Service}&p=${pubkey}`;
+        return `https://zkpassport.id/r?d=${this.domain}&t=${requestId}&c=${base64Config}&s=${base64Service}&p=${pubkey}&m=${this.topicToLocalConfig[requestId].mode}`;
     }
     /**
      * @notice Cancels a request by closing the WebSocket connection and deleting the associated data.