@zkpassport/sdk 0.3.0 → 0.3.2

package/dist/cjs/index.d.ts

@@ -17,6 +17,7 @@ export type QueryResultErrors = {
         commitment?: QueryResultError<string>;
         date?: QueryResultError<string>;
         certificate?: QueryResultError<string>;
+        scope?: QueryResultError<string>;
     };
 };
 export type SolidityVerifierParameters = {
@@ -26,6 +27,9 @@ export type SolidityVerifierParameters = {
     committedInputs: string;
     committedInputCounts: number[];
     validityPeriodInDays: number;
+    scope: string;
+    subscope: string;
+    devMode: boolean;
 };
 export type EVMChain = "ethereum_sepolia" | "local_anvil";
 export type * from "@zkpassport/utils";
@@ -192,15 +196,17 @@ export declare class ZKPassport {
      * @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)
      * @returns The query builder object.
      */
-    request({ name, logo, purpose, scope, mode, validity, topicOverride, keyPairOverride, }: {
+    request({ name, logo, purpose, scope, mode, validity, devMode, topicOverride, keyPairOverride, }: {
         name: string;
         logo: string;
         purpose: string;
         scope?: string;
         mode?: ProofMode;
         validity?: number;
+        devMode?: boolean;
         topicOverride?: string;
         keyPairOverride?: {
             privateKey: Uint8Array;
@@ -215,6 +221,8 @@ export declare class ZKPassport {
     private checkIssuingCountryExclusionPublicInputs;
     private checkNationalityInclusionPublicInputs;
     private checkIssuingCountryInclusionPublicInputs;
+    private checkScopeFromDisclosureProof;
+    private checkCertificateRegistryRoot;
     private checkPublicInputs;
     /**
      * @notice Verify the proofs received from the mobile app.
@@ -224,17 +232,20 @@ export declare class ZKPassport {
      * @returns An object containing the unique identifier associated to the user
      * and a boolean indicating whether the proofs were successfully verified.
      */
-    verify({ proofs, queryResult, validity, }: {
+    verify({ proofs, queryResult, validity, scope, devMode, }: {
         proofs: Array<ProofResult>;
         queryResult: QueryResult;
         validity?: number;
+        scope?: string;
+        devMode?: boolean;
     }): Promise<{
         uniqueIdentifier: string | undefined;
         verified: boolean;
         queryResultErrors?: QueryResultErrors;
     }>;
     getSolidityVerifierDetails(network: EVMChain): {
-        address: string;
+        address: `0x${string}`;
+        functionName: string;
         abi: {
             type: "function" | "event" | "constructor";
             name: string;
@@ -250,7 +261,13 @@ export declare class ZKPassport {
             }[];
         }[];
     };
-    getSolidityVerifierParameters(proof: ProofResult, validityPeriodInDays?: number): SolidityVerifierParameters;
+    getSolidityVerifierParameters({ proof, validityPeriodInDays, domain, scope, devMode, }: {
+        proof: ProofResult;
+        validityPeriodInDays?: number;
+        domain?: string;
+        scope?: string;
+        devMode?: boolean;
+    }): SolidityVerifierParameters;
     /**
      * @notice Returns the URL of the request.
      * @param requestId The request ID.

package/dist/cjs/index.js

@@ -13,9 +13,10 @@ const logger_1 = require("./logger");
 const pako_1 = require("pako");
 const en_json_1 = tslib_1.__importDefault(require("i18n-iso-countries/langs/en.json"));
 const buffer_1 = require("buffer/");
-const sha256_1 = require("@noble/hashes/sha256");
+const 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 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") {
@@ -40,9 +41,12 @@ function hasRequestedAccessToField(credentialsRequest, field) {
     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;
+    normalizedCountry = alpha3 || country || "ZKR";
     return normalizedCountry;
 }
 function numericalCompare(fnName, key, value, requestId, requestIdToConfig) {
@@ -105,6 +109,8 @@ class ZKPassport {
             proofs: this.topicToProofs[topic],
             queryResult: result,
             validity: this.topicToLocalConfig[topic]?.validity,
+            scope: this.topicToService[topic]?.scope,
+            devMode: this.topicToLocalConfig[topic]?.devMode,
         });
         delete this.topicToProofs[topic];
         const hasFailedProofs = this.topicToFailedProofCount[topic] > 0;
@@ -351,9 +357,10 @@ class ZKPassport {
      * @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)
      * @returns The query builder object.
      */
-    async request({ name, logo, purpose, scope, mode, validity, topicOverride, keyPairOverride, }) {
+    async request({ name, logo, purpose, scope, mode, validity, devMode, topicOverride, keyPairOverride, }) {
         const topic = topicOverride || (0, crypto_1.randomBytes)(16).toString("hex");
         const keyPair = keyPairOverride || (await (0, encryption_1.generateECDHKeyPair)());
         this.topicToKeyPair[topic] = {
@@ -368,6 +375,7 @@ class ZKPassport {
             // Default to 6 months
             validity: validity || 6 * 30,
             mode: mode || "fast",
+            devMode: devMode || false,
         };
         this.onRequestReceivedCallbacks[topic] = [];
         this.onGeneratingProofCallbacks[topic] = [];
@@ -1244,16 +1252,61 @@ class ZKPassport {
         }
         return { isCorrect, queryResultErrors };
     }
-    async checkPublicInputs(proofs, queryResult, validity) {
+    checkScopeFromDisclosureProof(proofData, queryResultErrors, key, scope) {
+        let isCorrect = true;
+        if (this.domain && (0, utils_1.getScopeHash)(this.domain) !== BigInt(proofData.publicInputs[1])) {
+            console.warn("The proof comes from a different domain than the one expected");
+            isCorrect = false;
+            queryResultErrors[key].scope = {
+                expected: `Scope: ${(0, utils_1.getScopeHash)(this.domain).toString()}`,
+                received: `Scope: ${BigInt(proofData.publicInputs[1]).toString()}`,
+                message: "The proof comes from a different domain than the one expected",
+            };
+        }
+        if (scope && (0, utils_1.getScopeHash)(scope) !== BigInt(proofData.publicInputs[2])) {
+            console.warn("The proof uses a different scope than the one expected");
+            isCorrect = false;
+            queryResultErrors[key].scope = {
+                expected: `Scope: ${(0, utils_1.getScopeHash)(scope).toString()}`,
+                received: `Scope: ${BigInt(proofData.publicInputs[2]).toString()}`,
+                message: "The proof uses a different scope than the one expected",
+            };
+        }
+        return { isCorrect, queryResultErrors };
+    }
+    async 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 });
+            await registryClient.getCertificates(`0x${root}`);
+        }
+        catch (error) {
+            console.warn(error);
+            // Check the legacy static roots that were used before the registry was deployed onchain
+            const VALID_CERTIFICATE_REGISTRY_ROOT = [
+                BigInt("20192042006788880778219739574377003123593792072535937278552252195461520776494"),
+                BigInt("21301853597069384763054217328384418971999152625381818922211526730996340553696"),
+                BigInt("10839898448097753834842514286432152806152415606387598803678317315409344029817"),
+            ];
+            if (!VALID_CERTIFICATE_REGISTRY_ROOT.includes(BigInt(root))) {
+                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 checkPublicInputs(proofs, queryResult, validity, scope) {
         let commitmentIn;
         let commitmentOut;
         let isCorrect = true;
         let uniqueIdentifier;
-        const VALID_CERTIFICATE_REGISTRY_ROOT = [
-            BigInt("20192042006788880778219739574377003123593792072535937278552252195461520776494"),
-            BigInt("21301853597069384763054217328384418971999152625381818922211526730996340553696"),
-            BigInt("10839898448097753834842514286432152806152415606387598803678317315409344029817"),
-        ];
         const currentTime = new Date();
         const today = new Date(currentTime.getFullYear(), currentTime.getMonth(), currentTime.getDate(), 0, 0, 0, 0);
         let queryResultErrors = {
@@ -1301,15 +1354,12 @@ class ZKPassport {
             if (proof.name?.startsWith("outer")) {
                 const isForEVM = proof.name?.startsWith("outer_evm");
                 const certificateRegistryRoot = (0, utils_1.getCertificateRegistryRootFromOuterProof)(proofData);
-                if (!VALID_CERTIFICATE_REGISTRY_ROOT.includes(certificateRegistryRoot)) {
-                    console.warn("The ID was signed by an unrecognized root certificate");
-                    isCorrect = false;
-                    queryResultErrors.outer.certificate = {
-                        expected: `Certificate registry root: ${VALID_CERTIFICATE_REGISTRY_ROOT.join(", ")}`,
-                        received: `Certificate registry root: ${certificateRegistryRoot.toString()}`,
-                        message: "The ID was signed by an unrecognized root certificate",
-                    };
-                }
+                const { isCorrect: isCorrectCertificateRegistryRoot, queryResultErrors: queryResultErrorsCertificateRegistryRoot, } = await this.checkCertificateRegistryRoot(certificateRegistryRoot.toString(16), queryResultErrors, true);
+                isCorrect = isCorrect && isCorrectCertificateRegistryRoot;
+                queryResultErrors = {
+                    ...queryResultErrors,
+                    ...queryResultErrorsCertificateRegistryRoot,
+                };
                 const currentDate = (0, utils_1.getCurrentDateFromOuterProof)(proofData);
                 const todayToCurrentDate = today.getTime() - currentDate.getTime();
                 const differenceInDays = validity ?? 180;
@@ -1337,6 +1387,24 @@ class ZKPassport {
                         message: "The proof does not verify all the requested conditions and information",
                     };
                 }
+                if (this.domain && (0, utils_1.getScopeHash)(this.domain) !== (0, utils_1.getScopeFromOuterProof)(proofData)) {
+                    console.warn("The proof comes from a different domain than the one expected");
+                    isCorrect = false;
+                    queryResultErrors.outer.scope = {
+                        expected: `Scope: ${(0, utils_1.getScopeHash)(this.domain).toString()}`,
+                        received: `Scope: ${(0, utils_1.getScopeFromOuterProof)(proofData).toString()}`,
+                        message: "The proof comes from a different domain than the one expected",
+                    };
+                }
+                if (scope && (0, utils_1.getScopeHash)(scope) !== (0, utils_1.getSubscopeFromOuterProof)(proofData)) {
+                    console.warn("The proof uses a different scope than the one expected");
+                    isCorrect = false;
+                    queryResultErrors.outer.scope = {
+                        expected: `Scope: ${(0, utils_1.getScopeHash)(scope).toString()}`,
+                        received: `Scope: ${(0, utils_1.getSubscopeFromOuterProof)(proofData).toString()}`,
+                        message: "The proof uses a different scope than the one expected",
+                    };
+                }
                 if (!!committedInputs?.compare_age) {
                     const ageCommittedInputs = committedInputs?.compare_age;
                     const ageParameterCommitment = isForEVM
@@ -1514,15 +1582,12 @@ class ZKPassport {
             else if (proof.name?.startsWith("sig_check_dsc")) {
                 commitmentOut = (0, utils_1.getCommitmentFromDSCProof)(proofData);
                 const merkleRoot = (0, utils_1.getMerkleRootFromDSCProof)(proofData);
-                if (!VALID_CERTIFICATE_REGISTRY_ROOT.includes(merkleRoot)) {
-                    console.warn("The ID was signed by an unrecognized root certificate");
-                    isCorrect = false;
-                    queryResultErrors.sig_check_dsc.certificate = {
-                        expected: `Certificate registry root: ${VALID_CERTIFICATE_REGISTRY_ROOT.join(", ")}`,
-                        received: `Certificate registry root: ${merkleRoot.toString()}`,
-                        message: "The ID was signed by an unrecognized root certificate",
-                    };
-                }
+                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);
@@ -1587,11 +1652,18 @@ class ZKPassport {
                         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;
+                isCorrect = isCorrect && isCorrectDisclose && isCorrectScope;
                 queryResultErrors = {
                     ...queryResultErrors,
                     ...queryResultErrorsDisclose,
+                    ...queryResultErrorsScope,
                 };
                 uniqueIdentifier = (0, utils_1.getNullifierFromDisclosureProof)(proofData).toString(10);
             }
@@ -1618,11 +1690,13 @@ class ZKPassport {
                         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;
+                isCorrect = isCorrect && isCorrectAge && isCorrectScope;
                 queryResultErrors = {
                     ...queryResultErrors,
                     ...queryResultErrorsAge,
+                    ...queryResultErrorsScope,
                 };
                 uniqueIdentifier = (0, utils_1.getNullifierFromDisclosureProof)(proofData).toString(10);
             }
@@ -1649,11 +1723,13 @@ class ZKPassport {
                         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;
+                isCorrect = isCorrect && isCorrectBirthdate && isCorrectScope;
                 queryResultErrors = {
                     ...queryResultErrors,
                     ...queryResultErrorsBirthdate,
+                    ...queryResultErrorsScope,
                 };
                 uniqueIdentifier = (0, utils_1.getNullifierFromDisclosureProof)(proofData).toString(10);
             }
@@ -1680,11 +1756,13 @@ class ZKPassport {
                         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;
+                isCorrect = isCorrect && isCorrectExpiryDate && isCorrectScope;
                 queryResultErrors = {
                     ...queryResultErrors,
                     ...queryResultErrorsExpiryDate,
+                    ...queryResultErrorsScope,
                 };
                 uniqueIdentifier = (0, utils_1.getNullifierFromDisclosureProof)(proofData).toString(10);
             }
@@ -1711,11 +1789,13 @@ class ZKPassport {
                         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;
+                isCorrect = isCorrect && isCorrectNationalityExclusion && isCorrectScope;
                 queryResultErrors = {
                     ...queryResultErrors,
                     ...queryResultErrorsNationalityExclusion,
+                    ...queryResultErrorsScope,
                 };
                 uniqueIdentifier = (0, utils_1.getNullifierFromDisclosureProof)(proofData).toString(10);
             }
@@ -1742,11 +1822,13 @@ class ZKPassport {
                         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;
+                isCorrect = isCorrect && isCorrectIssuingCountryExclusion && isCorrectScope;
                 queryResultErrors = {
                     ...queryResultErrors,
                     ...queryResultErrorsIssuingCountryExclusion,
+                    ...queryResultErrorsScope,
                 };
                 uniqueIdentifier = (0, utils_1.getNullifierFromDisclosureProof)(proofData).toString(10);
             }
@@ -1773,11 +1855,13 @@ class ZKPassport {
                         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;
+                isCorrect = isCorrect && isCorrectNationalityInclusion && isCorrectScope;
                 queryResultErrors = {
                     ...queryResultErrors,
                     ...queryResultErrorsNationalityInclusion,
+                    ...queryResultErrorsScope,
                 };
                 uniqueIdentifier = (0, utils_1.getNullifierFromDisclosureProof)(proofData).toString(10);
             }
@@ -1804,11 +1888,13 @@ class ZKPassport {
                         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;
+                isCorrect = isCorrect && isCorrectIssuingCountryInclusion && isCorrectScope;
                 queryResultErrors = {
                     ...queryResultErrors,
                     ...queryResultErrorsIssuingCountryInclusion,
+                    ...queryResultErrorsScope,
                 };
                 uniqueIdentifier = (0, utils_1.getNullifierFromDisclosureProof)(proofData).toString(10);
             }
@@ -1823,7 +1909,7 @@ class ZKPassport {
      * @returns An object containing the unique identifier associated to the user
      * and a boolean indicating whether the proofs were successfully verified.
      */
-    async verify({ proofs, queryResult, validity, }) {
+    async verify({ proofs, queryResult, validity, scope, devMode = false, }) {
         const formattedResult = queryResult;
         // Make sure to reconvert the dates to Date objects
         if (formattedResult.birthdate && formattedResult.birthdate.disclose) {
@@ -1837,10 +1923,17 @@ class ZKPassport {
         let verified = true;
         let uniqueIdentifier;
         let queryResultErrors;
-        const { isCorrect, uniqueIdentifier: uniqueIdentifierFromPublicInputs, queryResultErrors: queryResultErrorsFromPublicInputs, } = await this.checkPublicInputs(proofs, formattedResult, validity);
+        const { isCorrect, uniqueIdentifier: uniqueIdentifierFromPublicInputs, queryResultErrors: queryResultErrorsFromPublicInputs, } = await this.checkPublicInputs(proofs, formattedResult, validity, scope);
         uniqueIdentifier = uniqueIdentifierFromPublicInputs;
         verified = isCorrect;
         queryResultErrors = isCorrect ? undefined : queryResultErrorsFromPublicInputs;
+        if (uniqueIdentifier && BigInt(uniqueIdentifier) === BigInt(0) && !devMode) {
+            // If the unique identifier is 0 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) {
             for (const proof of proofs) {
@@ -1850,24 +1943,23 @@ class ZKPassport {
                     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 verifierDetails = this.getSolidityVerifierDetails("ethereum_sepolia");
+                        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);
+                        const params = this.getSolidityVerifierParameters({
+                            proof,
+                            validityPeriodInDays: validity,
+                            domain: this.domain,
+                            scope,
+                            devMode,
+                        });
                         const result = await client.readContract({
-                            address: verifierDetails.address,
-                            abi: verifierDetails.abi,
-                            functionName: "verifyProof",
-                            args: [
-                                params.vkeyHash,
-                                params.proof,
-                                params.publicInputs,
-                                params.committedInputs,
-                                params.committedInputCounts,
-                                params.validityPeriodInDays,
-                            ],
+                            address,
+                            abi,
+                            functionName,
+                            args: [params],
                         });
                         const isVerified = Array.isArray(result) ? Boolean(result[0]) : false;
                         verified = isVerified;
@@ -1902,21 +1994,25 @@ class ZKPassport {
         return { uniqueIdentifier, verified, queryResultErrors };
     }
     getSolidityVerifierDetails(network) {
+        const baseConfig = {
+            functionName: "verifyProof",
+            abi: ZKPassportVerifier_json_1.default.abi,
+        };
         if (network === "ethereum_sepolia") {
             return {
-                address: "0xca644D3424c2ee577FaaF2b56C0f9D1937E8e87C",
-                abi: ZKPassportVerifier_json_1.default.abi,
+                ...baseConfig,
+                address: "0x8c6982D77f7a8f60aE3133cA9b2FAA6f3e78c394",
             };
         }
         else if (network === "local_anvil") {
             return {
+                ...baseConfig,
                 address: "0x0",
-                abi: ZKPassportVerifier_json_1.default.abi,
             };
         }
         throw new Error(`Unsupported network: ${network}`);
     }
-    getSolidityVerifierParameters(proof, validityPeriodInDays = 7) {
+    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.");
         }
@@ -2008,7 +2104,7 @@ class ZKPassport {
         let committedInputCountsArray = [];
         for (const commitment of parameterCommitments) {
             const committedInput = committedInputs.find((x) => {
-                const rawHashedInputs = (0, sha256_1.sha256)((0, utils_3.hexToBytes)(x.inputs));
+                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);
@@ -2042,6 +2138,9 @@ class ZKPassport {
             committedInputs: `0x${compressedCommittedInputs}`,
             committedInputCounts: committedInputCountsArray,
             validityPeriodInDays,
+            scope: domain ?? this.domain,
+            subscope: scope ?? "",
+            devMode,
         };
         return params;
     }