@zkpassport/sdk 0.5.6 → 0.5.7-beta.10

package/dist/cjs/index.js

@@ -1,2345 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZKPassport = exports.MERCOSUR_COUNTRIES = exports.ASEAN_COUNTRIES = exports.SCHENGEN_COUNTRIES = exports.EEA_COUNTRIES = exports.EU_COUNTRIES = exports.SANCTIONED_COUNTRIES = void 0;
-const tslib_1 = require("tslib");
-const i18n_iso_countries_1 = require("i18n-iso-countries");
-const utils_1 = require("@zkpassport/utils");
-const utils_2 = require("@noble/ciphers/utils");
-const logger_1 = require("./logger");
-const en_json_1 = tslib_1.__importDefault(require("i18n-iso-countries/langs/en.json"));
-const buffer_1 = require("buffer/");
-const sha2_1 = require("@noble/hashes/sha2");
-const utils_3 = require("@noble/hashes/utils");
-const ZKPassportVerifier_json_1 = tslib_1.__importDefault(require("./assets/abi/ZKPassportVerifier.json"));
-const registry_1 = require("@zkpassport/registry");
-const bridge_1 = require("@obsidion/bridge");
-const VERSION = "0.5.5";
-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;
-    if (typeof window !== "undefined") {
-        window.Buffer = buffer_1.Buffer;
-    }
-}
-function getChainIdFromEVMChain(chain) {
-    if (chain === "ethereum_sepolia") {
-        return 11155111;
-    }
-    else if (chain === "local_anvil") {
-        return 31337;
-    }
-    throw new Error(`Unsupported chain: ${chain}`);
-}
-function getEVMChainFromChainId(chainId) {
-    if (chainId === 11155111) {
-        return "ethereum_sepolia";
-    }
-    else if (chainId === 31337) {
-        return "local_anvil";
-    }
-    throw new Error(`Unsupported chain ID: ${chainId}`);
-}
-(0, i18n_iso_countries_1.registerLocale)(en_json_1.default);
-function hasRequestedAccessToField(credentialsRequest, field) {
-    const fieldValue = credentialsRequest[field];
-    const isDefined = fieldValue !== undefined && fieldValue !== null;
-    if (!isDefined) {
-        return false;
-    }
-    for (const key in fieldValue) {
-        if (fieldValue[key] !== undefined &&
-            fieldValue[key] !== null) {
-            return true;
-        }
-    }
-    return false;
-}
-function normalizeCountry(country) {
-    if (country === "Zero Knowledge Republic") {
-        return "ZKR";
-    }
-    let normalizedCountry;
-    const alpha3 = (0, i18n_iso_countries_1.getAlpha3Code)(country, "en");
-    normalizedCountry = alpha3 || country || "ZKR";
-    return normalizedCountry;
-}
-function numericalCompare(fnName, key, value, requestId, requestIdToConfig) {
-    requestIdToConfig[requestId][key] = {
-        ...requestIdToConfig[requestId][key],
-        [fnName]: value,
-    };
-}
-function rangeCompare(key, value, requestId, requestIdToConfig) {
-    requestIdToConfig[requestId][key] = {
-        ...requestIdToConfig[requestId][key],
-        range: value,
-    };
-}
-function generalCompare(fnName, key, value, requestId, requestIdToConfig) {
-    requestIdToConfig[requestId][key] = {
-        ...requestIdToConfig[requestId][key],
-        [fnName]: value,
-    };
-}
-var 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) {
-        this.topicToConfig = {};
-        this.topicToLocalConfig = {};
-        this.topicToPublicKey = {};
-        this.topicToBridge = {};
-        this.topicToRequestReceived = {};
-        this.topicToService = {};
-        this.topicToProofs = {};
-        this.topicToExpectedProofCount = {};
-        this.topicToFailedProofCount = {};
-        this.topicToResults = {};
-        this.onRequestReceivedCallbacks = {};
-        this.onGeneratingProofCallbacks = {};
-        this.onBridgeConnectCallbacks = {};
-        this.onProofGeneratedCallbacks = {};
-        this.onResultCallbacks = {};
-        this.onRejectCallbacks = {};
-        this.onErrorCallbacks = {};
-        if (!_domain && typeof window === "undefined") {
-            throw new Error("Domain argument is required in Node.js environment");
-        }
-        this.domain = _domain || window.location.hostname;
-    }
-    async handleResult(topic) {
-        const result = this.topicToResults[topic];
-        // Clear the results straight away to avoid concurrency issues
-        delete this.topicToResults[topic];
-        // Verify the proofs and extract the unique identifier (aka nullifier) and the verification result
-        const { uniqueIdentifier, verified, queryResultErrors } = await this.verify({
-            proofs: this.topicToProofs[topic],
-            queryResult: result,
-            validity: this.topicToLocalConfig[topic]?.validity,
-            scope: this.topicToService[topic]?.scope,
-            evmChain: this.topicToService[topic]?.chainId
-                ? getEVMChainFromChainId(this.topicToService[topic]?.chainId)
-                : undefined,
-            devMode: this.topicToLocalConfig[topic]?.devMode,
-        });
-        delete this.topicToProofs[topic];
-        const hasFailedProofs = this.topicToFailedProofCount[topic] > 0;
-        await Promise.all(this.onResultCallbacks[topic].map((callback) => callback({
-            // If there are failed proofs, we don't return the unique identifier
-            // and we set the verified result to false
-            uniqueIdentifier: hasFailedProofs ? undefined : uniqueIdentifier,
-            verified: hasFailedProofs ? false : verified,
-            result,
-            queryResultErrors,
-        })));
-        // Clear the expected proof count and failed proof count
-        delete this.topicToExpectedProofCount[topic];
-        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
-        for (const field of fields) {
-            for (const key in this.topicToConfig[topic][field]) {
-                switch (key) {
-                    case "eq":
-                    case "disclose":
-                        if (field !== "age" && !neededCircuits.includes("disclose_bytes")) {
-                            neededCircuits.push("disclose_bytes");
-                        }
-                        else if (field === "age" && !neededCircuits.includes("compare_age")) {
-                            neededCircuits.push("compare_age");
-                        }
-                        break;
-                    case "gte":
-                    case "gt":
-                    case "lte":
-                    case "lt":
-                    case "range":
-                        if (field === "age" && !neededCircuits.includes("compare_age")) {
-                            neededCircuits.push("compare_age");
-                        }
-                        else if (field === "expiry_date" && !neededCircuits.includes("compare_expiry")) {
-                            neededCircuits.push("compare_expiry");
-                        }
-                        else if (field === "birthdate" && !neededCircuits.includes("compare_birthdate")) {
-                            neededCircuits.push("compare_birthdate");
-                        }
-                        break;
-                    case "in":
-                        if (field === "nationality" &&
-                            !neededCircuits.includes("inclusion_check_nationality")) {
-                            neededCircuits.push("inclusion_check_nationality");
-                        }
-                        else if (field === "issuing_country" &&
-                            !neededCircuits.includes("inclusion_check_issuing_country")) {
-                            neededCircuits.push("inclusion_check_issuing_country");
-                        }
-                        break;
-                    case "out":
-                        if (field === "nationality" &&
-                            !neededCircuits.includes("exclusion_check_nationality")) {
-                            neededCircuits.push("exclusion_check_nationality");
-                        }
-                        else if (field === "issuing_country" &&
-                            !neededCircuits.includes("exclusion_check_issuing_country")) {
-                            neededCircuits.push("exclusion_check_issuing_country");
-                        }
-                        break;
-                }
-            }
-        }
-        if (this.topicToConfig[topic].bind) {
-            neededCircuits.push("bind");
-        }
-        // From the circuits needed, determine the expected proof count
-        // There are at least 4 proofs, 3 base proofs and 1 disclosure proof minimum
-        // Each separate needed circuit adds 1 disclosure proof
-        this.topicToExpectedProofCount[topic] =
-            neededCircuits.length === 0 ? 4 : 3 + neededCircuits.length;
-        this.topicToFailedProofCount[topic] = 0;
-    }
-    /**
-     * @notice Handle an encrypted message.
-     * @param request The request.
-     * @param outerRequest The outer request.
-     */
-    async handleEncryptedMessage(topic, request) {
-        logger_1.noLogger.debug("Received encrypted message:", request);
-        if (request.method === "accept") {
-            logger_1.noLogger.debug(`User accepted the request and is generating a proof`);
-            await Promise.all(this.onGeneratingProofCallbacks[topic].map((callback) => callback(topic)));
-        }
-        else if (request.method === "reject") {
-            logger_1.noLogger.debug(`User rejected the request`);
-            await Promise.all(this.onRejectCallbacks[topic].map((callback) => callback()));
-        }
-        else if (request.method === "proof") {
-            logger_1.noLogger.debug(`User generated proof`);
-            this.topicToProofs[topic].push(request.params);
-            await Promise.all(this.onProofGeneratedCallbacks[topic].map((callback) => callback(request.params)));
-            // If the results were received before all the proofs were generated,
-            // we can handle the result now
-            if (this.topicToResults[topic] &&
-                this.topicToExpectedProofCount[topic] === this.topicToProofs[topic].length) {
-                await this.handleResult(topic);
-            }
-        }
-        else if (request.method === "done") {
-            logger_1.noLogger.debug(`User sent the query result`);
-            const formattedResult = request.params;
-            // Make sure to reconvert the dates to Date objects
-            if (formattedResult.birthdate && formattedResult.birthdate.disclose) {
-                formattedResult.birthdate.disclose.result = new Date(formattedResult.birthdate.disclose.result);
-            }
-            if (formattedResult.expiry_date && formattedResult.expiry_date.disclose) {
-                formattedResult.expiry_date.disclose.result = new Date(formattedResult.expiry_date.disclose.result);
-            }
-            this.topicToResults[topic] = formattedResult;
-            // Make sure all the proofs have been received, otherwise we'll handle the result later
-            // once the proofs have all been received
-            if (this.topicToExpectedProofCount[topic] === this.topicToProofs[topic].length) {
-                await this.handleResult(topic);
-            }
-        }
-        else if (request.method === "error") {
-            const error = request.params.error;
-            if (error && error === "This ID is not supported yet") {
-                // This means the user has an ID that is not supported yet
-                // So we won't receive any proofs and we can handle the result now
-                this.topicToExpectedProofCount[topic] = 0;
-                this.topicToFailedProofCount[topic] += this.topicToExpectedProofCount[topic];
-                if (this.topicToResults[topic]) {
-                    await this.handleResult(topic);
-                }
-            }
-            else if (error && error.startsWith("Cannot generate proof")) {
-                // This means one of the disclosure proofs failed to be generated
-                // So we need to remove one from the expected proof count
-                this.topicToExpectedProofCount[topic] -= 1;
-                this.topicToFailedProofCount[topic] += 1;
-                // If the expected proof count is now equal to the number of proofs received
-                // and the results were received, we can handle the result now
-                if (this.topicToResults[topic] &&
-                    this.topicToExpectedProofCount[topic] === this.topicToProofs[topic].length) {
-                    await this.handleResult(topic);
-                }
-            }
-            await Promise.all(this.onErrorCallbacks[topic].map((callback) => callback(error)));
-        }
-    }
-    getZkPassportRequest(topic) {
-        return {
-            eq: (key, value) => {
-                if (key === "issuing_country" || key === "nationality") {
-                    value = normalizeCountry(value);
-                }
-                generalCompare("eq", key, value, topic, this.topicToConfig);
-                return this.getZkPassportRequest(topic);
-            },
-            gte: (key, value) => {
-                numericalCompare("gte", key, value, topic, this.topicToConfig);
-                if (key === "age" && (value < 1 || value >= 100)) {
-                    throw new Error("Age must be between 1 and 99 (inclusive)");
-                }
-                return this.getZkPassportRequest(topic);
-            },
-            /*gt: <T extends NumericalIDCredential>(key: T, value: IDCredentialValue<T>) => {
-              numericalCompare('gt', key, value, topic, this.topicToConfig)
-              return this.getZkPassportRequest(topic)
-            },*/
-            lte: (key, value) => {
-                numericalCompare("lte", key, value, topic, this.topicToConfig);
-                return this.getZkPassportRequest(topic);
-            },
-            lt: (key, value) => {
-                numericalCompare("lt", key, value, topic, this.topicToConfig);
-                return this.getZkPassportRequest(topic);
-            },
-            range: (key, start, end) => {
-                rangeCompare(key, [start, end], topic, this.topicToConfig);
-                return this.getZkPassportRequest(topic);
-            },
-            in: (key, value) => {
-                value = value.map((v) => normalizeCountry(v));
-                generalCompare("in", key, value, topic, this.topicToConfig);
-                return this.getZkPassportRequest(topic);
-            },
-            out: (key, value) => {
-                value = value.map((v) => normalizeCountry(v));
-                generalCompare("out", key, value, topic, this.topicToConfig);
-                return this.getZkPassportRequest(topic);
-            },
-            disclose: (key) => {
-                this.topicToConfig[topic][key] = {
-                    ...this.topicToConfig[topic][key],
-                    disclose: true,
-                };
-                return this.getZkPassportRequest(topic);
-            },
-            bind: (key, value) => {
-                this.topicToConfig[topic].bind = {
-                    ...this.topicToConfig[topic].bind,
-                    [key]: value,
-                };
-                return this.getZkPassportRequest(topic);
-            },
-            done: () => {
-                this.setExpectedProofCount(topic);
-                return {
-                    url: this._getUrl(topic),
-                    requestId: topic,
-                    onRequestReceived: (callback) => this.onRequestReceivedCallbacks[topic].push(callback),
-                    onGeneratingProof: (callback) => this.onGeneratingProofCallbacks[topic].push(callback),
-                    onBridgeConnect: (callback) => this.onBridgeConnectCallbacks[topic].push(callback),
-                    onProofGenerated: (callback) => this.onProofGeneratedCallbacks[topic].push(callback),
-                    onResult: (callback) => this.onResultCallbacks[topic].push(callback),
-                    onReject: (callback) => this.onRejectCallbacks[topic].push(callback),
-                    onError: (callback) => this.onErrorCallbacks[topic].push(callback),
-                    isBridgeConnected: () => this.topicToBridge[topic].isBridgeConnected(),
-                    requestReceived: () => this.topicToRequestReceived[topic] === true,
-                };
-            },
-        };
-    }
-    /**
-     * @notice Create a new request
-     * @param name Your service name
-     * @param logo The logo of your service
-     * @param purpose To explain what you want to do with the user's data
-     * @param scope Scope this request to a specific use case
-     * @param validity How many days ago should have the ID been last scanned by the user?
-     * @param devMode Whether to enable dev mode. This will allow you to verify mock proofs (i.e. from ZKR)
-     * @param evmChain The EVM chain to use for the request (if using the proof onchain)
-     * @returns The query builder object.
-     */
-    async request({ name, logo, purpose, scope, mode, evmChain, validity, devMode, topicOverride, keyPairOverride, cloudProverUrl, bridgeUrl, }) {
-        const bridge = await bridge_1.Bridge.create({
-            keyPair: keyPairOverride,
-            bridgeId: topicOverride,
-            bridgeUrl,
-        });
-        const topic = bridge.connection.getBridgeId();
-        this.topicToConfig[topic] = {};
-        this.topicToService[topic] = {
-            name,
-            logo,
-            purpose,
-            scope,
-            chainId: evmChain ? getChainIdFromEVMChain(evmChain) : undefined,
-            cloudProverUrl,
-            bridgeUrl,
-        };
-        this.topicToProofs[topic] = [];
-        this.topicToExpectedProofCount[topic] = 0;
-        this.topicToLocalConfig[topic] = {
-            // Default to 6 months
-            validity: validity || 6 * 30,
-            mode: mode || "fast",
-            devMode: devMode || false,
-        };
-        this.onRequestReceivedCallbacks[topic] = [];
-        this.onGeneratingProofCallbacks[topic] = [];
-        this.onBridgeConnectCallbacks[topic] = [];
-        this.onProofGeneratedCallbacks[topic] = [];
-        this.onResultCallbacks[topic] = [];
-        this.onRejectCallbacks[topic] = [];
-        this.onErrorCallbacks[topic] = [];
-        this.topicToPublicKey[topic] = bridge.getPublicKey();
-        this.topicToBridge[topic] = bridge;
-        bridge.onConnect(async (reconnection) => {
-            logger_1.noLogger.debug("Bridge connected");
-            logger_1.noLogger.debug("Is reconnection:", reconnection);
-            await Promise.all(this.onBridgeConnectCallbacks[topic].map((callback) => callback()));
-        });
-        bridge.onSecureChannelEstablished(async () => {
-            logger_1.noLogger.debug("Secure channel established");
-            await Promise.all(this.onRequestReceivedCallbacks[topic].map((callback) => callback()));
-        });
-        bridge.onSecureMessage(async (message) => {
-            logger_1.noLogger.debug("Received message:", message);
-            this.handleEncryptedMessage(topic, message);
-        });
-        return this.getZkPassportRequest(topic);
-    }
-    checkDiscloseBytesPublicInputs(proof, queryResult) {
-        const queryResultErrors = {
-            sig_check_dsc: {},
-            sig_check_id_data: {},
-            data_check_integrity: {},
-            disclose: {},
-            age: {},
-            birthdate: {},
-            expiry_date: {},
-            document_type: {},
-            issuing_country: {},
-            gender: {},
-            nationality: {},
-            firstname: {},
-            lastname: {},
-            fullname: {},
-            document_number: {},
-            outer: {},
-            bind: {},
-        };
-        let isCorrect = true;
-        // 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: {},
-            data_check_integrity: {},
-            disclose: {},
-            age: {},
-            birthdate: {},
-            expiry_date: {},
-            document_type: {},
-            issuing_country: {},
-            gender: {},
-            nationality: {},
-            firstname: {},
-            lastname: {},
-            fullname: {},
-            document_number: {},
-            outer: {},
-            bind: {},
-        };
-        let isCorrect = true;
-        const currentTime = 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",
-                };
-            }
-            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.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: {},
-            bind: {},
-        };
-        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.birthdate.range = {
-                        expected: queryResult.birthdate.range.expected,
-                        received: [minDate, maxDate],
-                        message: "Birthdate is not in the expected range",
-                    };
-                }
-            }
-            if (!queryResult.birthdate.lte &&
-                !queryResult.birthdate.range &&
-                maxDate.getTime() != DEFAULT_DATE_VALUE.getTime()) {
-                console.warn("Maximum birthdate should be equal to default date value");
-                isCorrect = false;
-                queryResultErrors.birthdate.disclose = {
-                    expected: `${DEFAULT_DATE_VALUE.toISOString()}`,
-                    received: `${maxDate.toISOString()}`,
-                    message: "Maximum birthdate should be equal to default date value",
-                };
-            }
-            if (!queryResult.birthdate.gte &&
-                !queryResult.birthdate.range &&
-                minDate.getTime() != DEFAULT_DATE_VALUE.getTime()) {
-                console.warn("Minimum birthdate should be equal to default date value");
-                isCorrect = false;
-                queryResultErrors.birthdate.disclose = {
-                    expected: `${DEFAULT_DATE_VALUE.toISOString()}`,
-                    received: `${minDate.toISOString()}`,
-                    message: "Minimum birthdate should be equal to default date value",
-                };
-            }
-        }
-        else {
-            console.warn("Birthdate is not set in the query result");
-            isCorrect = false;
-            queryResultErrors.birthdate.disclose = {
-                message: "Birthdate is not set in the query result",
-            };
-        }
-        if (currentDate.getTime() !== today.getTime() &&
-            currentDate.getTime() !== today.getTime() - 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: {},
-            bind: {},
-        };
-        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.expiry_date.range = {
-                        expected: queryResult.expiry_date.range.expected,
-                        received: [minDate, maxDate],
-                        message: "Expiry date is not in the expected range",
-                    };
-                }
-            }
-            if (!queryResult.expiry_date.lte &&
-                !queryResult.expiry_date.range &&
-                maxDate.getTime() != DEFAULT_DATE_VALUE.getTime()) {
-                console.warn("Maximum expiry date should be equal to default date value");
-                isCorrect = false;
-                queryResultErrors.expiry_date.disclose = {
-                    expected: `${DEFAULT_DATE_VALUE.toISOString()}`,
-                    received: `${maxDate.toISOString()}`,
-                    message: "Maximum expiry date should be equal to default date value",
-                };
-            }
-            if (!queryResult.expiry_date.gte &&
-                !queryResult.expiry_date.range &&
-                minDate.getTime() != DEFAULT_DATE_VALUE.getTime()) {
-                console.warn("Minimum expiry date should be equal to default date value");
-                isCorrect = false;
-                queryResultErrors.expiry_date.disclose = {
-                    expected: `${DEFAULT_DATE_VALUE.toISOString()}`,
-                    received: `${minDate.toISOString()}`,
-                    message: "Minimum expiry date should be equal to default date value",
-                };
-            }
-        }
-        else {
-            console.warn("Expiry date is not set in the query result");
-            isCorrect = false;
-            queryResultErrors.expiry_date.disclose = {
-                message: "Expiry date is not set in the query result",
-            };
-        }
-        if (currentDate.getTime() !== today.getTime() &&
-            currentDate.getTime() !== today.getTime() - 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: {},
-            bind: {},
-        };
-        let isCorrect = true;
-        if (queryResult.nationality &&
-            queryResult.nationality.out &&
-            queryResult.nationality.out.result) {
-            if (!queryResult.nationality.out.expected?.every((country) => countryList.includes(country))) {
-                console.warn("Nationality exclusion list does not match the one from the query results");
-                isCorrect = false;
-                queryResultErrors.nationality.out = {
-                    expected: queryResult.nationality.out.expected,
-                    received: countryList,
-                    message: "Nationality exclusion list does not match the one from the query results",
-                };
-            }
-        }
-        else if (!queryResult.nationality || !queryResult.nationality.out) {
-            console.warn("Nationality exclusion is not set in the query result");
-            isCorrect = false;
-            queryResultErrors.nationality.out = {
-                message: "Nationality exclusion is not set in the query result",
-            };
-        }
-        // 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: {},
-            bind: {},
-        };
-        let isCorrect = true;
-        if (queryResult.issuing_country &&
-            queryResult.issuing_country.out &&
-            queryResult.issuing_country.out.result) {
-            if (!queryResult.issuing_country.out.expected?.every((country) => countryList.includes(country))) {
-                console.warn("Issuing country exclusion list does not match the one from the query results");
-                isCorrect = false;
-                queryResultErrors.issuing_country.out = {
-                    expected: queryResult.issuing_country.out.expected,
-                    received: countryList,
-                    message: "Issuing country exclusion list does not match the one from the query results",
-                };
-            }
-        }
-        else if (!queryResult.issuing_country || !queryResult.issuing_country.out) {
-            console.warn("Issuing country exclusion is not set in the query result");
-            isCorrect = false;
-            queryResultErrors.issuing_country.out = {
-                message: "Issuing country exclusion is not set in the query result",
-            };
-        }
-        // 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: {},
-            bind: {},
-        };
-        let isCorrect = true;
-        if (queryResult.nationality &&
-            queryResult.nationality.in &&
-            queryResult.nationality.in.result) {
-            if (!queryResult.nationality.in.expected?.every((country) => countryList.includes(country))) {
-                console.warn("Nationality inclusion list does not match the one from the query results");
-                isCorrect = false;
-                queryResultErrors.nationality.in = {
-                    expected: queryResult.nationality.in.expected,
-                    received: countryList,
-                    message: "Nationality inclusion list does not match the one from the query results",
-                };
-            }
-        }
-        else if (!queryResult.nationality || !queryResult.nationality.in) {
-            console.warn("Nationality inclusion is not set in the query result");
-            isCorrect = false;
-            queryResultErrors.nationality.in = {
-                message: "Nationality inclusion is not set in the query result",
-            };
-        }
-        return { isCorrect, queryResultErrors };
-    }
-    checkIssuingCountryInclusionPublicInputs(queryResult, countryList) {
-        const queryResultErrors = {
-            sig_check_dsc: {},
-            sig_check_id_data: {},
-            data_check_integrity: {},
-            disclose: {},
-            age: {},
-            birthdate: {},
-            expiry_date: {},
-            document_type: {},
-            issuing_country: {},
-            gender: {},
-            nationality: {},
-            firstname: {},
-            lastname: {},
-            fullname: {},
-            document_number: {},
-            outer: {},
-            bind: {},
-        };
-        let isCorrect = true;
-        if (queryResult.issuing_country &&
-            queryResult.issuing_country.in &&
-            queryResult.issuing_country.in.result) {
-            if (!queryResult.issuing_country.in.expected?.every((country) => countryList.includes(country))) {
-                console.warn("Issuing country inclusion list does not match the one from the query results");
-                isCorrect = false;
-                queryResultErrors.issuing_country.in = {
-                    expected: queryResult.issuing_country.in.expected,
-                    received: countryList,
-                    message: "Issuing country inclusion list does not match the one from the query results",
-                };
-            }
-        }
-        else if (!queryResult.issuing_country || !queryResult.issuing_country.in) {
-            console.warn("Issuing country inclusion is not set in the query result");
-            isCorrect = false;
-            queryResultErrors.issuing_country.in = {
-                message: "Issuing country inclusion is not set in the query result",
-            };
-        }
-        return { isCorrect, queryResultErrors };
-    }
-    checkScopeFromDisclosureProof(proofData, queryResultErrors, key, scope, chainId) {
-        let isCorrect = true;
-        if (this.domain &&
-            (0, utils_1.getServiceScopeHash)(this.domain, chainId) !== BigInt(proofData.publicInputs[1])) {
-            console.warn("The proof comes from a different domain than the one expected");
-            isCorrect = false;
-            queryResultErrors[key].scope = {
-                expected: `Scope: ${(0, utils_1.getServiceScopeHash)(this.domain, chainId).toString()}`,
-                received: `Scope: ${BigInt(proofData.publicInputs[1]).toString()}`,
-                message: "The proof comes from a different domain than the one expected",
-            };
-        }
-        if (scope && (0, 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 checkCertificateRegistryRoot(root, queryResultErrors, outer) {
-        let isCorrect = true;
-        try {
-            // Maintained certificate registry settled onchain
-            // Here we use Ethereum Sepolia
-            const registryClient = new registry_1.RegistryClient({ chainId: 11155111 });
-            const isValid = await registryClient.isCertificateRootValid(root);
-            if (!isValid) {
-                console.warn("The ID was signed by an unrecognized root certificate");
-                isCorrect = false;
-                queryResultErrors[outer ? "outer" : "sig_check_dsc"].certificate = {
-                    expected: `A valid root from ZKPassport Registry`,
-                    received: `Got invalid certificate registry root: ${root}`,
-                    message: "The ID was signed by an unrecognized root certificate",
-                };
-            }
-        }
-        catch (error) {
-            console.warn(error);
-            console.warn("The ID was signed by an unrecognized root certificate");
-            isCorrect = false;
-            queryResultErrors[outer ? "outer" : "sig_check_dsc"].certificate = {
-                expected: `A valid root from ZKPassport Registry`,
-                received: `Got invalid certificate registry root: ${root}`,
-                message: "The ID was signed by an unrecognized root certificate",
-            };
-        }
-        return { isCorrect, queryResultErrors };
-    }
-    async checkCircuitRegistryRoot(root, queryResultErrors) {
-        let isCorrect = true;
-        try {
-            const registryClient = new registry_1.RegistryClient({ chainId: 11155111 });
-            const isValid = await registryClient.isCircuitRootValid(root);
-            if (!isValid) {
-                console.warn("The proof uses unrecognized circuits");
-                isCorrect = false;
-                queryResultErrors.outer.circuit = {
-                    expected: `A valid circuit from ZKPassport Registry`,
-                    received: `Got invalid circuit registry root: ${root}`,
-                    message: "The proof uses an unrecognized circuit",
-                };
-            }
-        }
-        catch (error) {
-            console.warn(error);
-            console.warn("The proof uses unrecognized circuits");
-            isCorrect = false;
-            queryResultErrors.outer.circuit = {
-                expected: `A valid circuit from ZKPassport Registry`,
-                received: `Got invalid circuit registry root: ${root}`,
-                message: "The proof uses an unrecognized circuit",
-            };
-        }
-        return { isCorrect, queryResultErrors };
-    }
-    checkBindPublicInputs(queryResult, boundData) {
-        const queryResultErrors = {
-            sig_check_dsc: {},
-            sig_check_id_data: {},
-            data_check_integrity: {},
-            disclose: {},
-            age: {},
-            birthdate: {},
-            expiry_date: {},
-            document_type: {},
-            issuing_country: {},
-            gender: {},
-            nationality: {},
-            firstname: {},
-            lastname: {},
-            fullname: {},
-            document_number: {},
-            outer: {},
-            bind: {},
-        };
-        let isCorrect = true;
-        if (queryResult.bind) {
-            if (queryResult.bind.user_address?.toLowerCase().replace("0x", "") !==
-                boundData.user_address?.toLowerCase().replace("0x", "")) {
-                console.warn("Bound user address does not match the one from the query results");
-                isCorrect = false;
-                queryResultErrors.bind.eq = {
-                    expected: queryResult.bind.user_address,
-                    received: boundData.user_address,
-                    message: "Bound user address does not match the one from the query results",
-                };
-            }
-            if (queryResult.bind.custom_data?.trim().toLowerCase() !==
-                boundData.custom_data?.trim().toLowerCase()) {
-                console.warn("Bound custom data does not match the one from the query results");
-                isCorrect = false;
-                queryResultErrors.bind.eq = {
-                    expected: queryResult.bind.custom_data,
-                    received: boundData.custom_data,
-                    message: "Bound custom data does not match the one from the query results",
-                };
-            }
-        }
-        return { isCorrect, queryResultErrors };
-    }
-    async checkPublicInputs(proofs, queryResult, validity, scope, chainId) {
-        let commitmentIn;
-        let commitmentOut;
-        let isCorrect = true;
-        let uniqueIdentifier;
-        const currentTime = new Date();
-        const today = new Date(currentTime.getFullYear(), currentTime.getMonth(), currentTime.getDate(), 0, 0, 0, 0);
-        let queryResultErrors = {
-            sig_check_dsc: {},
-            sig_check_id_data: {},
-            data_check_integrity: {},
-            disclose: {},
-            age: {},
-            birthdate: {},
-            expiry_date: {},
-            document_type: {},
-            issuing_country: {},
-            gender: {},
-            nationality: {},
-            firstname: {},
-            lastname: {},
-            fullname: {},
-            document_number: {},
-            outer: {},
-            bind: {},
-        };
-        // 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",
-                "bind",
-            ];
-            const getIndex = (proof) => {
-                const name = proof.name || "";
-                return proofOrder.findIndex((p) => name.startsWith(p));
-            };
-            return getIndex(a) - getIndex(b);
-        });
-        for (const proof of sortedProofs) {
-            const proofData = (0, 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);
-                const { isCorrect: isCorrectCertificateRegistryRoot, queryResultErrors: queryResultErrorsCertificateRegistryRoot, } = await this.checkCertificateRegistryRoot(certificateRegistryRoot.toString(16), queryResultErrors, true);
-                isCorrect = isCorrect && isCorrectCertificateRegistryRoot;
-                queryResultErrors = {
-                    ...queryResultErrors,
-                    ...queryResultErrorsCertificateRegistryRoot,
-                };
-                const circuitRegistryRoot = (0, utils_1.getCircuitRegistryRootFromOuterProof)(proofData);
-                const { isCorrect: isCorrectCircuitRegistryRoot, queryResultErrors: queryResultErrorsCircuitRegistryRoot, } = await this.checkCircuitRegistryRoot(circuitRegistryRoot.toString(16), queryResultErrors);
-                isCorrect = isCorrect && isCorrectCircuitRegistryRoot;
-                queryResultErrors = {
-                    ...queryResultErrors,
-                    ...queryResultErrorsCircuitRegistryRoot,
-                };
-                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.getServiceScopeHash)(this.domain, chainId) !== (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.getServiceScopeHash)(this.domain, chainId).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 (!!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.age.commitment = {
-                            expected: `Age parameter commitment: ${ageParameterCommitment.toString()}`,
-                            received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
-                            message: "This proof does not verify the age",
-                        };
-                    }
-                    const { isCorrect: isCorrectAge, queryResultErrors: queryResultErrorsAge } = this.checkAgePublicInputs(proof, queryResult);
-                    isCorrect = isCorrect && isCorrectAge;
-                    queryResultErrors = {
-                        ...queryResultErrors,
-                        ...queryResultErrorsAge,
-                    };
-                }
-                else if (!!committedInputs?.compare_birthdate) {
-                    const birthdateCommittedInputs = committedInputs?.compare_birthdate;
-                    const birthdateParameterCommitment = isForEVM
-                        ? await (0, 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.birthdate.commitment = {
-                            expected: `Birthdate parameter commitment: ${birthdateParameterCommitment.toString()}`,
-                            received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
-                            message: "This proof does not verify the birthdate",
-                        };
-                    }
-                    const { isCorrect: isCorrectBirthdate, queryResultErrors: queryResultErrorsBirthdate } = this.checkBirthdatePublicInputs(proof, queryResult);
-                    isCorrect = isCorrect && isCorrectBirthdate;
-                    queryResultErrors = {
-                        ...queryResultErrors,
-                        ...queryResultErrorsBirthdate,
-                    };
-                }
-                else if (!!committedInputs?.compare_expiry) {
-                    const expiryCommittedInputs = committedInputs?.compare_expiry;
-                    const expiryParameterCommitment = isForEVM
-                        ? await (0, 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.expiry_date.commitment = {
-                            expected: `Expiry date parameter commitment: ${expiryParameterCommitment.toString()}`,
-                            received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
-                            message: "This proof does not verify the expiry date",
-                        };
-                    }
-                    const { isCorrect: isCorrectExpiryDate, queryResultErrors: queryResultErrorsExpiryDate } = this.checkExpiryDatePublicInputs(proof, queryResult);
-                    isCorrect = isCorrect && isCorrectExpiryDate;
-                    queryResultErrors = {
-                        ...queryResultErrors,
-                        ...queryResultErrorsExpiryDate,
-                    };
-                }
-                else if (!!committedInputs?.disclose_bytes) {
-                    const discloseCommittedInputs = committedInputs?.disclose_bytes;
-                    const discloseParameterCommitment = isForEVM
-                        ? await (0, 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.disclose.commitment = {
-                            expected: `Disclosure parameter commitment: ${discloseParameterCommitment.toString()}`,
-                            received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
-                            message: "This proof does not verify any of the data disclosed",
-                        };
-                    }
-                    const { isCorrect: isCorrectDisclose, queryResultErrors: queryResultErrorsDisclose } = this.checkDiscloseBytesPublicInputs(proof, queryResult);
-                    isCorrect = isCorrect && isCorrectDisclose;
-                    queryResultErrors = {
-                        ...queryResultErrors,
-                        ...queryResultErrorsDisclose,
-                    };
-                }
-                else if (!!committedInputs?.inclusion_check_nationality) {
-                    const inclusionCheckNationalityCommittedInputs = committedInputs?.inclusion_check_nationality;
-                    const inclusionCheckNationalityParameterCommitment = isForEVM
-                        ? await (0, 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.nationality.commitment = {
-                            expected: `Nationality parameter commitment: ${inclusionCheckNationalityParameterCommitment.toString()}`,
-                            received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
-                            message: "This proof does not verify the inclusion of the nationality",
-                        };
-                    }
-                    const countryList = inclusionCheckNationalityCommittedInputs.countries;
-                    const { isCorrect: isCorrectNationalityInclusion, queryResultErrors: queryResultErrorsNationalityInclusion, } = this.checkNationalityInclusionPublicInputs(queryResult, countryList);
-                    isCorrect = isCorrect && isCorrectNationalityInclusion;
-                    queryResultErrors = {
-                        ...queryResultErrors,
-                        ...queryResultErrorsNationalityInclusion,
-                    };
-                }
-                else if (!!committedInputs?.inclusion_check_issuing_country) {
-                    const inclusionCheckIssuingCountryCommittedInputs = committedInputs?.inclusion_check_issuing_country;
-                    const inclusionCheckIssuingCountryParameterCommitment = isForEVM
-                        ? await (0, 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.issuing_country.commitment = {
-                            expected: `Issuing country parameter commitment: ${inclusionCheckIssuingCountryParameterCommitment.toString()}`,
-                            received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
-                            message: "This proof does not verify the inclusion of the issuing country",
-                        };
-                    }
-                    const countryList = inclusionCheckIssuingCountryCommittedInputs.countries;
-                    const { isCorrect: isCorrectIssuingCountryInclusion, queryResultErrors: queryResultErrorsIssuingCountryInclusion, } = this.checkIssuingCountryInclusionPublicInputs(queryResult, countryList);
-                    isCorrect = isCorrect && isCorrectIssuingCountryInclusion;
-                    queryResultErrors = {
-                        ...queryResultErrors,
-                        ...queryResultErrorsIssuingCountryInclusion,
-                    };
-                }
-                else if (!!committedInputs?.exclusion_check_nationality) {
-                    const exclusionCheckNationalityCommittedInputs = committedInputs?.exclusion_check_nationality;
-                    const exclusionCheckNationalityParameterCommitment = isForEVM
-                        ? await (0, 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.nationality.commitment = {
-                            expected: `Nationality parameter commitment: ${exclusionCheckNationalityParameterCommitment.toString()}`,
-                            received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
-                            message: "This proof does not verify the exclusion of the nationality",
-                        };
-                    }
-                    const countryList = exclusionCheckNationalityCommittedInputs.countries;
-                    const { isCorrect: isCorrectNationalityExclusion, queryResultErrors: queryResultErrorsNationalityExclusion, } = this.checkNationalityExclusionPublicInputs(queryResult, countryList);
-                    isCorrect = isCorrect && isCorrectNationalityExclusion;
-                    queryResultErrors = {
-                        ...queryResultErrors,
-                        ...queryResultErrorsNationalityExclusion,
-                    };
-                }
-                else if (!!committedInputs?.exclusion_check_issuing_country) {
-                    const exclusionCheckIssuingCountryCommittedInputs = committedInputs?.exclusion_check_issuing_country;
-                    const exclusionCheckIssuingCountryParameterCommitment = isForEVM
-                        ? await (0, 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.issuing_country.commitment = {
-                            expected: `Issuing country parameter commitment: ${exclusionCheckIssuingCountryParameterCommitment.toString()}`,
-                            received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
-                            message: "This proof does not verify the exclusion of the issuing country",
-                        };
-                    }
-                    const countryList = exclusionCheckIssuingCountryCommittedInputs.countries;
-                    const { isCorrect: isCorrectIssuingCountryExclusion, queryResultErrors: queryResultErrorsIssuingCountryExclusion, } = this.checkIssuingCountryExclusionPublicInputs(queryResult, countryList);
-                    isCorrect = isCorrect && isCorrectIssuingCountryExclusion;
-                    queryResultErrors = {
-                        ...queryResultErrors,
-                        ...queryResultErrorsIssuingCountryExclusion,
-                    };
-                }
-                else if (!!committedInputs?.bind) {
-                    const bindCommittedInputs = committedInputs?.bind;
-                    const bindParameterCommitment = isForEVM
-                        ? await (0, utils_1.getBindEVMParameterCommitment)((0, utils_1.formatBoundData)(bindCommittedInputs.data))
-                        : await (0, utils_1.getBindParameterCommitment)((0, utils_1.formatBoundData)(bindCommittedInputs.data));
-                    if (!paramCommitments.includes(bindParameterCommitment)) {
-                        console.warn("This proof does not verify the bound data");
-                        isCorrect = false;
-                        queryResultErrors.bind.commitment = {
-                            expected: `Bind parameter commitment: ${bindParameterCommitment.toString()}`,
-                            received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
-                            message: "This proof does not verify the bound data",
-                        };
-                    }
-                    const { isCorrect: isCorrectBind, queryResultErrors: queryResultErrorsBind } = this.checkBindPublicInputs(queryResult, bindCommittedInputs.data);
-                    isCorrect = isCorrect && isCorrectBind;
-                    queryResultErrors = {
-                        ...queryResultErrors,
-                        ...queryResultErrorsBind,
-                    };
-                }
-                uniqueIdentifier = (0, 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);
-                const { isCorrect: isCorrectCertificateRegistryRoot, queryResultErrors: queryResultErrorsCertificateRegistryRoot, } = await this.checkCertificateRegistryRoot(merkleRoot.toString(16), queryResultErrors, false);
-                isCorrect = isCorrect && isCorrectCertificateRegistryRoot;
-                queryResultErrors = {
-                    ...queryResultErrors,
-                    ...queryResultErrorsCertificateRegistryRoot,
-                };
-            }
-            else if (proof.name?.startsWith("sig_check_id_data")) {
-                commitmentIn = (0, 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") {
-                commitmentIn = (0, utils_1.getCommitmentInFromDisclosureProof)(proofData);
-                if (commitmentIn !== commitmentOut) {
-                    console.warn("Failed to check the link between the validity of the ID and the age derived from it");
-                    isCorrect = false;
-                    queryResultErrors.age.commitment = {
-                        expected: `Commitment: ${commitmentOut}`,
-                        received: `Commitment: ${commitmentIn}`,
-                        message: "Failed to check the link between the validity of the ID and the age derived from it",
-                    };
-                }
-                const paramCommitment = (0, 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.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") {
-                commitmentIn = (0, utils_1.getCommitmentInFromDisclosureProof)(proofData);
-                if (commitmentIn !== commitmentOut) {
-                    console.warn("Failed to check the link between the validity of the ID and the birthdate derived from it");
-                    isCorrect = false;
-                    queryResultErrors.birthdate.commitment = {
-                        expected: `Commitment: ${commitmentOut}`,
-                        received: `Commitment: ${commitmentIn}`,
-                        message: "Failed to check the link between the validity of the ID and the birthdate derived from it",
-                    };
-                }
-                const paramCommitment = (0, 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.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") {
-                commitmentIn = (0, utils_1.getCommitmentInFromDisclosureProof)(proofData);
-                if (commitmentIn !== commitmentOut) {
-                    console.warn("Failed to check the link between the validity of the ID and its expiry date");
-                    isCorrect = false;
-                    queryResultErrors.expiry_date.commitment = {
-                        expected: `Commitment: ${commitmentOut}`,
-                        received: `Commitment: ${commitmentIn}`,
-                        message: "Failed to check the link between the validity of the ID and its expiry date",
-                    };
-                }
-                const paramCommitment = (0, 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.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") {
-                commitmentIn = (0, utils_1.getCommitmentInFromDisclosureProof)(proofData);
-                if (commitmentIn !== commitmentOut) {
-                    console.warn("Failed to check the link between the validity of the ID and the nationality exclusion check");
-                    isCorrect = false;
-                    queryResultErrors.nationality.commitment = {
-                        expected: `Commitment: ${commitmentOut}`,
-                        received: `Commitment: ${commitmentIn}`,
-                        message: "Failed to check the link between the validity of the ID and the nationality exclusion check",
-                    };
-                }
-                const countryList = (proof.committedInputs?.exclusion_check_nationality).countries;
-                const paramCommittment = (0, 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.commitment = {
-                        expected: `Commitment: ${calculatedParamCommitment}`,
-                        received: `Commitment: ${paramCommittment}`,
-                        message: "The committed country list for the exclusion check does not match the one from the proof",
-                    };
-                }
-                const { isCorrect: isCorrectScope, queryResultErrors: queryResultErrorsScope } = this.checkScopeFromDisclosureProof(proofData, queryResultErrors, "nationality", scope);
-                const { isCorrect: isCorrectNationalityExclusion, queryResultErrors: queryResultErrorsNationalityExclusion, } = this.checkNationalityExclusionPublicInputs(queryResult, countryList);
-                isCorrect = isCorrect && isCorrectNationalityExclusion && isCorrectScope;
-                queryResultErrors = {
-                    ...queryResultErrors,
-                    ...queryResultErrorsNationalityExclusion,
-                    ...queryResultErrorsScope,
-                };
-                uniqueIdentifier = (0, utils_1.getNullifierFromDisclosureProof)(proofData).toString(10);
-            }
-            else if (proof.name === "exclusion_check_issuing_country") {
-                commitmentIn = (0, utils_1.getCommitmentInFromDisclosureProof)(proofData);
-                if (commitmentIn !== commitmentOut) {
-                    console.warn("Failed to check the link between the validity of the ID and the issuing country exclusion check");
-                    isCorrect = false;
-                    queryResultErrors.nationality.commitment = {
-                        expected: `Commitment: ${commitmentOut}`,
-                        received: `Commitment: ${commitmentIn}`,
-                        message: "Failed to check the link between the validity of the ID and the issuing country exclusion check",
-                    };
-                }
-                const countryList = (proof.committedInputs?.exclusion_check_issuing_country).countries;
-                const paramCommittment = (0, 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.commitment = {
-                        expected: `Commitment: ${calculatedParamCommitment}`,
-                        received: `Commitment: ${paramCommittment}`,
-                        message: "The committed country list for the issuing country exclusion check does not match the one from the proof",
-                    };
-                }
-                const { isCorrect: isCorrectScope, queryResultErrors: queryResultErrorsScope } = this.checkScopeFromDisclosureProof(proofData, queryResultErrors, "nationality", scope);
-                const { isCorrect: isCorrectIssuingCountryExclusion, queryResultErrors: queryResultErrorsIssuingCountryExclusion, } = this.checkIssuingCountryExclusionPublicInputs(queryResult, countryList);
-                isCorrect = isCorrect && isCorrectIssuingCountryExclusion && isCorrectScope;
-                queryResultErrors = {
-                    ...queryResultErrors,
-                    ...queryResultErrorsIssuingCountryExclusion,
-                    ...queryResultErrorsScope,
-                };
-                uniqueIdentifier = (0, utils_1.getNullifierFromDisclosureProof)(proofData).toString(10);
-            }
-            else if (proof.name === "inclusion_check_nationality") {
-                commitmentIn = (0, utils_1.getCommitmentInFromDisclosureProof)(proofData);
-                if (commitmentIn !== commitmentOut) {
-                    console.warn("Failed to check the link between the validity of the ID and the nationality inclusion check");
-                    isCorrect = false;
-                    queryResultErrors.nationality.commitment = {
-                        expected: `Commitment: ${commitmentOut}`,
-                        received: `Commitment: ${commitmentIn}`,
-                        message: "Failed to check the link between the validity of the ID and the nationality inclusion check",
-                    };
-                }
-                const countryList = (proof.committedInputs?.inclusion_check_nationality).countries;
-                const paramCommittment = (0, 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.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") {
-                commitmentIn = (0, utils_1.getCommitmentInFromDisclosureProof)(proofData);
-                if (commitmentIn !== commitmentOut) {
-                    console.warn("Failed to check the link between the validity of the ID and the issuing country inclusion check");
-                    isCorrect = false;
-                    queryResultErrors.nationality.commitment = {
-                        expected: `Commitment: ${commitmentOut}`,
-                        received: `Commitment: ${commitmentIn}`,
-                        message: "Failed to check the link between the validity of the ID and the issuing country inclusion check",
-                    };
-                }
-                const countryList = (proof.committedInputs?.inclusion_check_issuing_country).countries;
-                const paramCommittment = (0, 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.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);
-            }
-            else if (proof.name === "bind") {
-                const bindCommittedInputs = proof.committedInputs?.bind;
-                const paramCommittment = (0, utils_1.getParameterCommitmentFromDisclosureProof)(proofData);
-                const calculatedParamCommitment = await (0, utils_1.getBindParameterCommitment)((0, utils_1.formatBoundData)(bindCommittedInputs.data));
-                if (paramCommittment !== calculatedParamCommitment) {
-                    console.warn("The bound data does not match the one from the proof");
-                    isCorrect = false;
-                    queryResultErrors.bind.commitment = {
-                        expected: `Commitment: ${calculatedParamCommitment}`,
-                        received: `Commitment: ${paramCommittment}`,
-                        message: "The bound data does not match the one from the proof",
-                    };
-                }
-                const { isCorrect: isCorrectBind, queryResultErrors: queryResultErrorsBind } = this.checkBindPublicInputs(queryResult, bindCommittedInputs.data);
-                isCorrect = isCorrect && isCorrectBind;
-                queryResultErrors = {
-                    ...queryResultErrors,
-                    ...queryResultErrorsBind,
-                };
-                uniqueIdentifier = (0, utils_1.getNullifierFromDisclosureProof)(proofData).toString(10);
-            }
-        }
-        return { isCorrect, uniqueIdentifier, queryResultErrors };
-    }
-    /**
-     * @notice Verify the proofs received from the mobile app.
-     * @param proofs The proofs to verify.
-     * @param queryResult The query result to verify against
-     * @param validity How many days ago should have the ID been last scanned by the user?
-     * @param scope Scope this request to a specific use case
-     * @param evmChain The EVM chain to use for the verification (if using the proof onchain)
-     * @param devMode Whether to enable dev mode. This will allow you to verify mock proofs (i.e. from ZKR)
-     * @param writingDirectory The directory (e.g. `./tmp`) where the necessary temporary artifacts for verification are written to.
-     * It should only be needed when running the `verify` function on a server with restricted write access (e.g. Vercel)
-     * @returns An object containing the unique identifier associated to the user
-     * and a boolean indicating whether the proofs were successfully verified.
-     */
-    async verify({ proofs, queryResult, validity, scope, evmChain, devMode = false, writingDirectory, }) {
-        // If no proofs were generated, the results can't be trusted.
-        // We still return it but verified will be false
-        if (!proofs || proofs.length === 0) {
-            return {
-                uniqueIdentifier: undefined,
-                verified: false,
-            };
-        }
-        const formattedResult = queryResult;
-        // Make sure to reconvert the dates to Date objects
-        if (formattedResult.birthdate && formattedResult.birthdate.disclose) {
-            formattedResult.birthdate.disclose.result = new Date(formattedResult.birthdate.disclose.result);
-        }
-        if (formattedResult.expiry_date && formattedResult.expiry_date.disclose) {
-            formattedResult.expiry_date.disclose.result = new Date(formattedResult.expiry_date.disclose.result);
-        }
-        const { BarretenbergVerifier } = await Promise.resolve().then(() => tslib_1.__importStar(require("@aztec/bb.js")));
-        // Automatically set the writing directory to `/tmp` if it is not provided
-        // and the code is not running in the browser
-        if (typeof window === "undefined" && !writingDirectory) {
-            writingDirectory = "/tmp";
-        }
-        const verifier = new BarretenbergVerifier({
-            crsPath: writingDirectory ? writingDirectory + "/.bb-crs" : undefined,
-        });
-        let verified = true;
-        let uniqueIdentifier;
-        let queryResultErrors;
-        const chainId = evmChain ? getChainIdFromEVMChain(evmChain) : undefined;
-        const { isCorrect, uniqueIdentifier: uniqueIdentifierFromPublicInputs, queryResultErrors: queryResultErrorsFromPublicInputs, } = await this.checkPublicInputs(proofs, formattedResult, validity, scope, chainId);
-        uniqueIdentifier = uniqueIdentifierFromPublicInputs;
-        verified = isCorrect;
-        queryResultErrors = isCorrect ? undefined : queryResultErrorsFromPublicInputs;
-        if (uniqueIdentifier &&
-            (BigInt(uniqueIdentifier) === BigInt(1) || BigInt(uniqueIdentifier) === BigInt(0)) &&
-            !devMode) {
-            // If the unique identifier is 0 (old ZKR proofs) or 1 (new ZKR proofs) and it is not in dev mode,
-            // the proofs are considered invalid as these are mock proofs only meant
-            // for testing purposes
-            verified = false;
-            console.warn("You are trying to verify a mock proof. This is only allowed in dev mode. To enable dev mode, set the `devMode` parameter to `true` in the request function parameters.");
-        }
-        // Only proceed with the proof verification if the public inputs are correct
-        if (verified) {
-            const registryClient = new registry_1.RegistryClient({ chainId: 11155111 });
-            const circuitManifest = await registryClient.getCircuitManifest(undefined, {
-                // We assume all proofs have the same version
-                version: proofs[0].version,
-            });
-            for (const proof of proofs) {
-                const proofData = (0, utils_1.getProofData)(proof.proof, (0, utils_1.getNumberOfPublicInputs)(proof.name));
-                const hostedPackagedCircuit = await registryClient.getPackagedCircuit(proof.name, circuitManifest);
-                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,
-                            devMode,
-                        });
-                        const result = await client.readContract({
-                            address,
-                            abi,
-                            functionName,
-                            args: [params],
-                        });
-                        const isVerified = Array.isArray(result) ? Boolean(result[0]) : false;
-                        verified = isVerified;
-                    }
-                    catch (error) {
-                        console.warn("Error verifying proof", error);
-                        verified = false;
-                    }
-                }
-                else {
-                    const vkeyBytes = 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
-                    // and don't bother checking the other proofs
-                    break;
-                }
-            }
-        }
-        // If the proofs are not verified, we don't return the unique identifier
-        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: "0xDDeFf76024052D26B78A7Fac66FFbd6fbc5bd9Ad",
-            };
-        }
-        else if (network === "local_anvil") {
-            return {
-                ...baseConfig,
-                address: "0x0",
-            };
-        }
-        throw new Error(`Unsupported network: ${network}`);
-    }
-    getSolidityVerifierParameters({ proof, validityPeriodInDays = 7, domain, scope, devMode = false, }) {
-        if (!proof.name?.startsWith("outer_evm")) {
-            throw new Error("This proof cannot be verified on an EVM chain. Please make sure to use the `compressed-evm` mode.");
-        }
-        const proofData = (0, 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 if (circuitName === "bind_evm") {
-                const value = proof.committedInputs[circuitName];
-                compressedCommittedInputs =
-                    utils_1.ProofType.BIND.toString(16).padStart(2, "0") +
-                        (0, utils_1.rightPadArrayWithZeros)((0, utils_1.formatBoundData)(value.data), 500)
-                            .map((x) => x.toString(16).padStart(2, "0"))
-                            .join("");
-            }
-            else {
-                throw new Error(`Unsupported circuit for EVM verification: ${circuitName}`);
-            }
-            committedInputs.push({ circuitName, inputs: compressedCommittedInputs });
-        }
-        const parameterCommitments = proofData.publicInputs.slice(12, proofData.publicInputs.length - 1);
-        let compressedCommittedInputs = "";
-        let committedInputCountsArray = [];
-        for (const commitment of parameterCommitments) {
-            const committedInput = committedInputs.find((x) => {
-                const rawHashedInputs = (0, sha2_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,
-            domain: domain ?? this.domain,
-            scope: scope ?? "",
-            devMode,
-        };
-        return params;
-    }
-    _getUrl(requestId) {
-        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");
-        const pubkey = this.topicToPublicKey[requestId];
-        return `https://zkpassport.id/r?d=${this.domain}&t=${requestId}&c=${base64Config}&s=${base64Service}&p=${pubkey}&m=${this.topicToLocalConfig[requestId].mode}&v=${VERSION}`;
-    }
-    /**
-     * @notice Returns the URL of the request.
-     * @param requestId The request ID.
-     * @returns The URL of the request.
-     */
-    getUrl(requestId) {
-        return this._getUrl(requestId);
-    }
-    /**
-     * @notice Cancels a request by closing the WebSocket connection and deleting the associated data.
-     * @param requestId The request ID.
-     */
-    cancelRequest(requestId) {
-        if (this.topicToBridge[requestId]) {
-            this.topicToBridge[requestId].close();
-            delete this.topicToBridge[requestId];
-        }
-        delete this.topicToPublicKey[requestId];
-        delete this.topicToConfig[requestId];
-        delete this.topicToLocalConfig[requestId];
-        delete this.topicToProofs[requestId];
-        delete this.topicToExpectedProofCount[requestId];
-        delete this.topicToFailedProofCount[requestId];
-        delete this.topicToResults[requestId];
-        this.onRequestReceivedCallbacks[requestId] = [];
-        this.onGeneratingProofCallbacks[requestId] = [];
-        this.onBridgeConnectCallbacks[requestId] = [];
-        this.onProofGeneratedCallbacks[requestId] = [];
-        this.onRejectCallbacks[requestId] = [];
-        this.onErrorCallbacks[requestId] = [];
-    }
-    /**
-     * @notice Clears all requests.
-     */
-    clearAllRequests() {
-        for (const requestId in this.topicToBridge) {
-            this.cancelRequest(requestId);
-        }
-    }
-}
-exports.ZKPassport = ZKPassport;