@zkpassport/sdk 0.2.9 → 0.2.11

package/dist/esm/index.js

@@ -7,8 +7,6 @@ import { createEncryptedJsonRpcRequest } from "./json-rpc";
 import { decrypt, generateECDHKeyPair, getSharedSecret } from "./encryption";
 import { noLogger as logger } from "./logger";
 import { inflate } from "pako";
-//import initNoirC from '@noir-lang/noirc_abi'
-//import initACVM from '@noir-lang/acvm_js'
 import i18en from "i18n-iso-countries/langs/en.json";
 import { Buffer } from "buffer/";
 // If Buffer is not defined, then we use the Buffer from the buffer package
@@ -84,18 +82,17 @@ export class ZKPassport {
         }
         this.domain = _domain || window.location.hostname;
     }
-    /*private async initWasmVerifier() {
-      const acvm = await import('@noir-lang/acvm_js/web/acvm_js_bg.wasm')
-      const noirc = await import('@noir-lang/noirc_abi/web/noirc_abi_wasm_bg.wasm')
-      await Promise.all([initACVM(acvm), initNoirC(noirc)])
-      this.wasmVerifierInit = true
-    }*/
     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(topic, this.topicToProofs[topic], result);
+        const { uniqueIdentifier, verified, queryResultErrors } = await this.verify({
+            proofs: this.topicToProofs[topic],
+            queryResult: result,
+            validity: this.topicToLocalConfig[topic]?.validity,
+        });
+        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
@@ -141,13 +138,23 @@ export class ZKPassport {
                         }
                         break;
                     case "in":
-                        if (field === "nationality" && !neededCircuits.includes("inclusion_check_country")) {
-                            neededCircuits.push("inclusion_check_country");
+                        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_country")) {
-                            neededCircuits.push("exclusion_check_country");
+                        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;
                 }
@@ -381,7 +388,7 @@ export class ZKPassport {
         };
         return this.getZkPassportRequest(topic);
     }
-    async checkPublicInputs(proofs, queryResult, topic) {
+    async checkPublicInputs(proofs, queryResult, validity) {
         let commitmentIn;
         let commitmentOut;
         let isCorrect = true;
@@ -418,8 +425,10 @@ export class ZKPassport {
                 "compare_age",
                 "compare_birthdate",
                 "compare_expiry",
-                "exclusion_check_country",
-                "inclusion_check_country",
+                "exclusion_check_nationality",
+                "inclusion_check_nationality",
+                "exclusion_check_issuing_country",
+                "inclusion_check_issuing_country",
             ];
             const getIndex = (proof) => {
                 const name = proof.name || "";
@@ -469,14 +478,15 @@ export class ZKPassport {
                 commitmentOut = getCommitmentOutFromIntegrityProof(proofData);
                 const currentDate = getCurrentDateFromIntegrityProof(proofData);
                 const todayToCurrentDate = today.getTime() - currentDate.getTime();
-                const expectedDifference = this.topicToLocalConfig[topic]?.validity * 86400000;
+                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 ${this.topicToLocalConfig[topic]?.validity} days. You can ask the user to rescan their ID or ask them to disclose their expiry date`);
+                    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: ${this.topicToLocalConfig[topic]?.validity} days`,
+                        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",
                     };
@@ -506,7 +516,7 @@ export class ZKPassport {
                         isCorrect = false;
                         queryResultErrors.document_type.eq = {
                             expected: `${queryResult.document_type.eq.expected}`,
-                            received: `${disclosedDataPassport.documentType}`,
+                            received: `${disclosedDataPassport.documentType ?? disclosedDataIDCard.documentType}`,
                             message: "Document type does not match the expected document type",
                         };
                     }
@@ -515,7 +525,7 @@ export class ZKPassport {
                         isCorrect = false;
                         queryResultErrors.document_type.disclose = {
                             expected: `${queryResult.document_type.disclose?.result}`,
-                            received: `${disclosedDataIDCard.documentType}`,
+                            received: `${disclosedDataIDCard.documentType ?? disclosedDataPassport.documentType}`,
                             message: "Document type does not match the disclosed document type in query result",
                         };
                     }
@@ -531,7 +541,7 @@ export class ZKPassport {
                         isCorrect = false;
                         queryResultErrors.birthdate.eq = {
                             expected: `${queryResult.birthdate.eq.expected.toISOString()}`,
-                            received: `${birthdatePassport.toISOString()}`,
+                            received: `${birthdatePassport?.toISOString() ?? birthdateIDCard?.toISOString()}`,
                             message: "Birthdate does not match the expected birthdate",
                         };
                     }
@@ -542,7 +552,7 @@ export class ZKPassport {
                         isCorrect = false;
                         queryResultErrors.birthdate.disclose = {
                             expected: `${queryResult.birthdate.disclose.result.toISOString()}`,
-                            received: `${birthdatePassport.toISOString()}`,
+                            received: `${birthdatePassport?.toISOString() ?? birthdateIDCard?.toISOString()}`,
                             message: "Birthdate does not match the disclosed birthdate in query result",
                         };
                     }
@@ -558,7 +568,7 @@ export class ZKPassport {
                         isCorrect = false;
                         queryResultErrors.expiry_date.eq = {
                             expected: `${queryResult.expiry_date.eq.expected.toISOString()}`,
-                            received: `${expiryDatePassport.toISOString()}`,
+                            received: `${expiryDatePassport?.toISOString() ?? expiryDateIDCard?.toISOString()}`,
                             message: "Expiry date does not match the expected expiry date",
                         };
                     }
@@ -569,7 +579,7 @@ export class ZKPassport {
                         isCorrect = false;
                         queryResultErrors.expiry_date.disclose = {
                             expected: `${queryResult.expiry_date.disclose.result.toISOString()}`,
-                            received: `${expiryDatePassport.toISOString()}`,
+                            received: `${expiryDatePassport?.toISOString() ?? expiryDateIDCard?.toISOString()}`,
                             message: "Expiry date does not match the disclosed expiry date in query result",
                         };
                     }
@@ -585,7 +595,7 @@ export class ZKPassport {
                         isCorrect = false;
                         queryResultErrors.nationality.eq = {
                             expected: `${queryResult.nationality.eq.expected}`,
-                            received: `${nationalityPassport}`,
+                            received: `${nationalityPassport ?? nationalityIDCard}`,
                             message: "Nationality does not match the expected nationality",
                         };
                     }
@@ -596,7 +606,7 @@ export class ZKPassport {
                         isCorrect = false;
                         queryResultErrors.nationality.disclose = {
                             expected: `${queryResult.nationality.disclose.result}`,
-                            received: `${nationalityPassport}`,
+                            received: `${nationalityPassport ?? nationalityIDCard}`,
                             message: "Nationality does not match the disclosed nationality in query result",
                         };
                     }
@@ -612,7 +622,7 @@ export class ZKPassport {
                         isCorrect = false;
                         queryResultErrors.document_number.eq = {
                             expected: `${queryResult.document_number.eq.expected}`,
-                            received: `${documentNumberPassport}`,
+                            received: `${documentNumberPassport ?? documentNumberIDCard}`,
                             message: "Document number does not match the expected document number",
                         };
                     }
@@ -623,7 +633,7 @@ export class ZKPassport {
                         isCorrect = false;
                         queryResultErrors.document_number.disclose = {
                             expected: `${queryResult.document_number.disclose.result}`,
-                            received: `${documentNumberPassport}`,
+                            received: `${documentNumberPassport ?? documentNumberIDCard}`,
                             message: "Document number does not match the disclosed document number in query result",
                         };
                     }
@@ -639,7 +649,7 @@ export class ZKPassport {
                         isCorrect = false;
                         queryResultErrors.gender.eq = {
                             expected: `${queryResult.gender.eq.expected}`,
-                            received: `${genderPassport}`,
+                            received: `${genderPassport ?? genderIDCard}`,
                             message: "Gender does not match the expected gender",
                         };
                     }
@@ -650,7 +660,7 @@ export class ZKPassport {
                         isCorrect = false;
                         queryResultErrors.gender.disclose = {
                             expected: `${queryResult.gender.disclose.result}`,
-                            received: `${genderPassport}`,
+                            received: `${genderPassport ?? genderIDCard}`,
                             message: "Gender does not match the disclosed gender in query result",
                         };
                     }
@@ -666,7 +676,7 @@ export class ZKPassport {
                         isCorrect = false;
                         queryResultErrors.issuing_country.eq = {
                             expected: `${queryResult.issuing_country.eq.expected}`,
-                            received: `${issuingCountryPassport}`,
+                            received: `${issuingCountryPassport ?? issuingCountryIDCard}`,
                             message: "Issuing country does not match the expected issuing country",
                         };
                     }
@@ -677,7 +687,7 @@ export class ZKPassport {
                         isCorrect = false;
                         queryResultErrors.issuing_country.disclose = {
                             expected: `${queryResult.issuing_country.disclose.result}`,
-                            received: `${issuingCountryPassport}`,
+                            received: `${issuingCountryPassport ?? issuingCountryIDCard}`,
                             message: "Issuing country does not match the disclosed issuing country in query result",
                         };
                     }
@@ -695,7 +705,7 @@ export class ZKPassport {
                         isCorrect = false;
                         queryResultErrors.fullname.eq = {
                             expected: `${queryResult.fullname.eq.expected}`,
-                            received: `${fullnamePassport}`,
+                            received: `${fullnamePassport ?? fullnameIDCard}`,
                             message: "Fullname does not match the expected fullname",
                         };
                     }
@@ -708,7 +718,7 @@ export class ZKPassport {
                         isCorrect = false;
                         queryResultErrors.fullname.disclose = {
                             expected: `${queryResult.fullname.disclose.result}`,
-                            received: `${fullnamePassport}`,
+                            received: `${fullnamePassport ?? fullnameIDCard}`,
                             message: "Fullname does not match the disclosed fullname in query result",
                         };
                     }
@@ -731,7 +741,7 @@ export class ZKPassport {
                         isCorrect = false;
                         queryResultErrors.firstname.eq = {
                             expected: `${queryResult.firstname.eq.expected}`,
-                            received: `${firstnamePassport}`,
+                            received: `${firstnamePassport ?? firstnameIDCard}`,
                             message: "Firstname does not match the expected firstname",
                         };
                     }
@@ -744,7 +754,7 @@ export class ZKPassport {
                         isCorrect = false;
                         queryResultErrors.firstname.disclose = {
                             expected: `${queryResult.firstname.disclose.result}`,
-                            received: `${firstnamePassport}`,
+                            received: `${firstnamePassport ?? firstnameIDCard}`,
                             message: "Firstname does not match the disclosed firstname in query result",
                         };
                     }
@@ -767,7 +777,7 @@ export class ZKPassport {
                         isCorrect = false;
                         queryResultErrors.lastname.eq = {
                             expected: `${queryResult.lastname.eq.expected}`,
-                            received: `${lastnamePassport}`,
+                            received: `${lastnamePassport ?? lastnameIDCard}`,
                             message: "Lastname does not match the expected lastname",
                         };
                     }
@@ -780,7 +790,7 @@ export class ZKPassport {
                         isCorrect = false;
                         queryResultErrors.lastname.disclose = {
                             expected: `${queryResult.lastname.disclose.result}`,
-                            received: `${lastnamePassport}`,
+                            received: `${lastnamePassport ?? lastnameIDCard}`,
                             message: "Lastname does not match the disclosed lastname in query result",
                         };
                     }
@@ -884,7 +894,7 @@ export class ZKPassport {
                         message: "Current date in the proof is too old",
                     };
                 }
-                uniqueIdentifier = getCommitmentInFromDisclosureProof(proofData).toString(10);
+                uniqueIdentifier = getNullifierFromDisclosureProof(proofData).toString(10);
             }
             else if (proof.name === "compare_birthdate") {
                 commitmentIn = getCommitmentInFromDisclosureProof(proofData);
@@ -965,7 +975,7 @@ export class ZKPassport {
                         message: "Birthdate is not set in the query result",
                     };
                 }
-                uniqueIdentifier = getCommitmentInFromDisclosureProof(proofData).toString(10);
+                uniqueIdentifier = getNullifierFromDisclosureProof(proofData).toString(10);
             }
             else if (proof.name === "compare_expiry") {
                 commitmentIn = getCommitmentInFromDisclosureProof(proofData);
@@ -1048,15 +1058,15 @@ export class ZKPassport {
                 }
                 uniqueIdentifier = getNullifierFromDisclosureProof(proofData).toString(10);
             }
-            else if (proof.name === "exclusion_check_country") {
+            else if (proof.name === "exclusion_check_nationality") {
                 commitmentIn = getCommitmentInFromDisclosureProof(proofData);
                 if (commitmentIn !== commitmentOut) {
-                    console.warn("Failed to check the link between the validity of the ID and the country exclusion check");
+                    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 country exclusion check",
+                        message: "Failed to check the link between the validity of the ID and the nationality exclusion check",
                     };
                 }
                 const countryList = getCountryListFromExclusionProof(proofData);
@@ -1064,12 +1074,12 @@ export class ZKPassport {
                     queryResult.nationality.out &&
                     queryResult.nationality.out.result) {
                     if (!queryResult.nationality.out.expected?.every((country) => countryList.includes(country))) {
-                        console.warn("Country exclusion list does not match the one from the query results");
+                        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: "Country exclusion list does not match the one from the query results",
+                            message: "Nationality exclusion list does not match the one from the query results",
                         };
                     }
                 }
@@ -1094,15 +1104,61 @@ export class ZKPassport {
                 }
                 uniqueIdentifier = getNullifierFromDisclosureProof(proofData).toString(10);
             }
-            else if (proof.name === "inclusion_check_country") {
+            else if (proof.name === "exclusion_check_issuing_country") {
+                commitmentIn = 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 = getCountryListFromExclusionProof(proofData);
+                if (queryResult.issuing_country &&
+                    queryResult.issuing_country.out &&
+                    queryResult.issuing_country.out.result) {
+                    if (!queryResult.issuing_country.out.expected?.every((country) => countryList.includes(country))) {
+                        console.warn("Issuing country exclusion list does not match the one from the query results");
+                        isCorrect = false;
+                        queryResultErrors.issuing_country.out = {
+                            expected: queryResult.issuing_country.out.expected,
+                            received: countryList,
+                            message: "Issuing country exclusion list does not match the one from the query results",
+                        };
+                    }
+                }
+                else if (!queryResult.issuing_country || !queryResult.issuing_country.out) {
+                    console.warn("Issuing country exclusion is not set in the query result");
+                    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",
+                        };
+                    }
+                }
+                uniqueIdentifier = getNullifierFromDisclosureProof(proofData).toString(10);
+            }
+            else if (proof.name === "inclusion_check_nationality") {
                 commitmentIn = getCommitmentInFromDisclosureProof(proofData);
                 if (commitmentIn !== commitmentOut) {
-                    console.warn("Failed to check the link between the validity of the ID and the country inclusion check");
+                    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 country inclusion check",
+                        message: "Failed to check the link between the validity of the ID and the nationality inclusion check",
                     };
                 }
                 const countryList = getCountryListFromInclusionProof(proofData);
@@ -1110,12 +1166,12 @@ export class ZKPassport {
                     queryResult.nationality.in &&
                     queryResult.nationality.in.result) {
                     if (!queryResult.nationality.in.expected?.every((country) => countryList.includes(country))) {
-                        console.warn("Country inclusion list does not match the one from the query results");
+                        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: "Country inclusion list does not match the one from the query results",
+                            message: "Nationality inclusion list does not match the one from the query results",
                         };
                     }
                 }
@@ -1128,40 +1184,64 @@ export class ZKPassport {
                 }
                 uniqueIdentifier = getNullifierFromDisclosureProof(proofData).toString(10);
             }
+            else if (proof.name === "inclusion_check_issuing_country") {
+                commitmentIn = 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 = getCountryListFromInclusionProof(proofData);
+                if (queryResult.issuing_country &&
+                    queryResult.issuing_country.in &&
+                    queryResult.issuing_country.in.result) {
+                    if (!queryResult.issuing_country.in.expected?.every((country) => countryList.includes(country))) {
+                        console.warn("Issuing country inclusion list does not match the one from the query results");
+                        isCorrect = false;
+                        queryResultErrors.issuing_country.in = {
+                            expected: queryResult.issuing_country.in.expected,
+                            received: countryList,
+                            message: "Issuing country inclusion list does not match the one from the query results",
+                        };
+                    }
+                }
+                else if (!queryResult.issuing_country || !queryResult.issuing_country.in) {
+                    console.warn("Issuing country inclusion is not set in the query result");
+                    isCorrect = false;
+                    queryResultErrors.issuing_country.in = {
+                        message: "Issuing country inclusion is not set in the query result",
+                    };
+                }
+                uniqueIdentifier = getNullifierFromDisclosureProof(proofData).toString(10);
+            }
         }
         return { isCorrect, uniqueIdentifier, queryResultErrors };
     }
     /**
      * @notice Verify the proofs received from the mobile app.
-     * @param requestId The request ID.
      * @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?
      * @returns An object containing the unique identifier associated to the user
      * and a boolean indicating whether the proofs were successfully verified.
      */
-    async verify(requestId, proofs, queryResult) {
-        let proofsToVerify = proofs;
-        // There is a minimum of 4 subproofs to make a complete proof
-        if (!proofs || proofs.length < 4) {
-            proofsToVerify = this.topicToProofs[requestId];
-        }
+    async verify({ proofs, queryResult, validity, }) {
         const { BarretenbergVerifier } = await import("@aztec/bb.js");
         const verifier = new BarretenbergVerifier();
-        /*if (!this.wasmVerifierInit) {
-          await this.initWasmVerifier()
-        }*/
         let verified = true;
         let uniqueIdentifier;
         let queryResultErrors;
-        if (queryResult) {
-            const { isCorrect, uniqueIdentifier: uniqueIdentifierFromPublicInputs, queryResultErrors: queryResultErrorsFromPublicInputs, } = await this.checkPublicInputs(proofsToVerify, queryResult, requestId);
-            uniqueIdentifier = uniqueIdentifierFromPublicInputs;
-            verified = isCorrect;
-            queryResultErrors = isCorrect ? undefined : queryResultErrorsFromPublicInputs;
-        }
+        const { isCorrect, uniqueIdentifier: uniqueIdentifierFromPublicInputs, queryResultErrors: queryResultErrorsFromPublicInputs, } = await this.checkPublicInputs(proofs, queryResult, validity);
+        uniqueIdentifier = uniqueIdentifierFromPublicInputs;
+        verified = isCorrect;
+        queryResultErrors = isCorrect ? undefined : queryResultErrorsFromPublicInputs;
         // Only proceed with the proof verification if the public inputs are correct
-        if (verified && queryResult) {
-            for (const proof of proofsToVerify) {
+        if (verified) {
+            for (const proof of proofs) {
                 const proofData = getProofData(proof.proof, true);
                 const hostedPackagedCircuit = await getHostedPackagedCircuitByName(proof.version, proof.name);
                 const vkeyBytes = Buffer.from(hostedPackagedCircuit.vkey, "base64");
@@ -1179,7 +1259,8 @@ export class ZKPassport {
                 }
             }
         }
-        this.topicToProofs[requestId] = [];
+        // If the proofs are not verified, we don't return the unique identifier
+        uniqueIdentifier = verified ? uniqueIdentifier : undefined;
         return { uniqueIdentifier, verified, queryResultErrors };
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zkpassport/sdk",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "description": "Privacy-preserving identity verification using passports and ID cards",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
@@ -38,10 +38,10 @@
     "typescript": "^5.6.2"
   },
   "dependencies": {
-    "@aztec/bb.js": "^0.67.0",
+    "@aztec/bb.js": "^0.76.4",
     "@noble/ciphers": "^1.2.1",
     "@noble/secp256k1": "^2.2.3",
-    "@zkpassport/utils": "^0.2.16",
+    "@zkpassport/utils": "^0.2.23",
     "buffer": "^6.0.3",
     "i18n-iso-countries": "^7.12.0",
     "pako": "^2.1.0",