@zkpassport/sdk 0.3.4 → 0.4.1

package/dist/cjs/index.d.ts

@@ -1,11 +1,11 @@
-import { type DisclosableIDCredential, type IDCredential, type IDCredentialValue, type NumericalIDCredential, type ProofResult, type QueryResult, ProofMode } from "@zkpassport/utils";
+import { type DisclosableIDCredential, type IDCredential, type IDCredentialValue, type NumericalIDCredential, type ProofResult, type QueryResult, ProofMode, BoundData } from "@zkpassport/utils";
 export type QueryResultError<T> = {
     expected?: T;
     received?: T;
     message: string;
 };
 export type QueryResultErrors = {
-    [key in IDCredential | "sig_check_dsc" | "sig_check_id_data" | "data_check_integrity" | "outer" | "disclose"]: {
+    [key in IDCredential | "sig_check_dsc" | "sig_check_id_data" | "data_check_integrity" | "outer" | "disclose" | "bind"]: {
         disclose?: QueryResultError<string | number | Date>;
         gte?: QueryResultError<number | Date>;
         lte?: QueryResultError<number | Date>;
@@ -150,6 +150,12 @@ export type QueryBuilder = {
      * @param key The attribute to disclose.
      */
     disclose: (key: DisclosableIDCredential) => QueryBuilder;
+    /**
+     * Binds a value to the request.
+     * @param key The key of the value to bind.
+     * @param value The value to bind the request to.
+     */
+    bind: (key: keyof BoundData, value: BoundData[keyof BoundData]) => QueryBuilder;
     /**
      * Builds the request.
      *
@@ -163,9 +169,8 @@ export declare class ZKPassport {
     private domain;
     private topicToConfig;
     private topicToLocalConfig;
-    private topicToKeyPair;
-    private topicToWebSocketClient;
-    private topicToSharedSecret;
+    private topicToPublicKey;
+    private topicToBridge;
     private topicToRequestReceived;
     private topicToService;
     private topicToProofs;
@@ -197,14 +202,16 @@ export declare class ZKPassport {
      * @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.
      */
-    request({ name, logo, purpose, scope, mode, validity, devMode, topicOverride, keyPairOverride, }: {
+    request({ name, logo, purpose, scope, mode, evmChain, validity, devMode, topicOverride, keyPairOverride, }: {
         name: string;
         logo: string;
         purpose: string;
         scope?: string;
         mode?: ProofMode;
+        evmChain?: EVMChain;
         validity?: number;
         devMode?: boolean;
         topicOverride?: string;
@@ -223,20 +230,25 @@ export declare class ZKPassport {
     private checkIssuingCountryInclusionPublicInputs;
     private checkScopeFromDisclosureProof;
     private checkCertificateRegistryRoot;
+    private checkBindPublicInputs;
     private checkPublicInputs;
     /**
      * @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)
      * @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, scope, devMode, }: {
+    verify({ proofs, queryResult, validity, scope, evmChain, devMode, }: {
         proofs: Array<ProofResult>;
         queryResult: QueryResult;
         validity?: number;
         scope?: string;
+        evmChain?: EVMChain;
         devMode?: boolean;
     }): Promise<{
         uniqueIdentifier: string | undefined;

package/dist/cjs/index.js

@@ -2,21 +2,17 @@
 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 crypto_1 = require("crypto");
 const i18n_iso_countries_1 = require("i18n-iso-countries");
 const utils_1 = require("@zkpassport/utils");
 const utils_2 = require("@noble/ciphers/utils");
-const websocket_1 = require("./websocket");
-const json_rpc_1 = require("./json-rpc");
-const encryption_1 = require("./encryption");
 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 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 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") {
@@ -25,6 +21,24 @@ if (typeof globalThis.Buffer === "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];
@@ -79,9 +93,8 @@ class ZKPassport {
     constructor(_domain) {
         this.topicToConfig = {};
         this.topicToLocalConfig = {};
-        this.topicToKeyPair = {};
-        this.topicToWebSocketClient = {};
-        this.topicToSharedSecret = {};
+        this.topicToPublicKey = {};
+        this.topicToBridge = {};
         this.topicToRequestReceived = {};
         this.topicToService = {};
         this.topicToProofs = {};
@@ -110,6 +123,9 @@ class ZKPassport {
             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];
@@ -185,6 +201,9 @@ class ZKPassport {
                 }
             }
         }
+        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
@@ -197,7 +216,7 @@ class ZKPassport {
      * @param request The request.
      * @param outerRequest The outer request.
      */
-    async handleEncryptedMessage(topic, request, outerRequest) {
+    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`);
@@ -209,30 +228,8 @@ class ZKPassport {
         }
         else if (request.method === "proof") {
             logger_1.noLogger.debug(`User generated proof`);
-            // Uncompress the proof and convert it to a hex string
-            const bytesProof = buffer_1.Buffer.from(request.params.proof, "base64");
-            const bytesCommittedInputs = request.params.committedInputs
-                ? buffer_1.Buffer.from(request.params.committedInputs, "base64")
-                : null;
-            const uncompressedProof = (0, pako_1.inflate)(bytesProof);
-            const uncompressedCommittedInputs = bytesCommittedInputs
-                ? (0, pako_1.inflate)(bytesCommittedInputs)
-                : null;
-            // The gzip lib in the app compress the proof as ASCII
-            // and since the app passes the proof as a hex string, we can
-            // just decode the bytes as hex characters using the TextDecoder
-            const hexProof = new TextDecoder().decode(uncompressedProof);
-            const processedProof = {
-                proof: hexProof,
-                vkeyHash: request.params.vkeyHash,
-                name: request.params.name,
-                version: request.params.version,
-                committedInputs: uncompressedCommittedInputs
-                    ? JSON.parse(new TextDecoder().decode(uncompressedCommittedInputs))
-                    : undefined,
-            };
-            this.topicToProofs[topic].push(processedProof);
-            await Promise.all(this.onProofGeneratedCallbacks[topic].map((callback) => callback(processedProof)));
+            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] &&
@@ -329,10 +326,17 @@ class ZKPassport {
                 };
                 return this.getZkPassportRequest(topic);
             },
+            bind: (key, value) => {
+                this.topicToConfig[topic].bind = {
+                    ...this.topicToConfig[topic].bind,
+                    [key]: value,
+                };
+                return this.getZkPassportRequest(topic);
+            },
             done: () => {
                 const base64Config = buffer_1.Buffer.from(JSON.stringify(this.topicToConfig[topic])).toString("base64");
                 const base64Service = buffer_1.Buffer.from(JSON.stringify(this.topicToService[topic])).toString("base64");
-                const pubkey = (0, utils_2.bytesToHex)(this.topicToKeyPair[topic].publicKey);
+                const pubkey = this.topicToPublicKey[topic];
                 this.setExpectedProofCount(topic);
                 return {
                     url: `https://zkpassport.id/r?d=${this.domain}&t=${topic}&c=${base64Config}&s=${base64Service}&p=${pubkey}&m=${this.topicToLocalConfig[topic].mode}`,
@@ -344,7 +348,7 @@ class ZKPassport {
                     onResult: (callback) => this.onResultCallbacks[topic].push(callback),
                     onReject: (callback) => this.onRejectCallbacks[topic].push(callback),
                     onError: (callback) => this.onErrorCallbacks[topic].push(callback),
-                    isBridgeConnected: () => this.topicToWebSocketClient[topic].readyState === WebSocket.OPEN,
+                    isBridgeConnected: () => this.topicToBridge[topic].isBridgeConnected(),
                     requestReceived: () => this.topicToRequestReceived[topic] === true,
                 };
             },
@@ -358,17 +362,23 @@ class ZKPassport {
      * @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, 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] = {
-            privateKey: keyPair.privateKey,
-            publicKey: keyPair.publicKey,
-        };
+    async request({ name, logo, purpose, scope, mode, evmChain, validity, devMode, topicOverride, keyPairOverride, }) {
+        const bridge = await bridge_1.Bridge.create({
+            keyPair: keyPairOverride,
+            bridgeId: topicOverride,
+        });
+        const topic = bridge.connection.getBridgeId();
         this.topicToConfig[topic] = {};
-        this.topicToService[topic] = { name, logo, purpose, scope };
+        this.topicToService[topic] = {
+            name,
+            logo,
+            purpose,
+            scope,
+            chainId: evmChain ? getChainIdFromEVMChain(evmChain) : undefined,
+        };
         this.topicToProofs[topic] = [];
         this.topicToExpectedProofCount[topic] = 0;
         this.topicToLocalConfig[topic] = {
@@ -384,53 +394,21 @@ class ZKPassport {
         this.onResultCallbacks[topic] = [];
         this.onRejectCallbacks[topic] = [];
         this.onErrorCallbacks[topic] = [];
-        const wsClient = (0, websocket_1.getWebSocketClient)(`wss://bridge.zkpassport.id?topic=${topic}`, this.domain);
-        this.topicToWebSocketClient[topic] = wsClient;
-        wsClient.onopen = async () => {
-            logger_1.noLogger.info("[frontend] WebSocket connection established");
+        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()));
-        };
-        wsClient.addEventListener("message", async (event) => {
-            logger_1.noLogger.debug("[frontend] Received message:", event.data);
-            try {
-                const data = JSON.parse(event.data);
-                // Handshake happens when the mobile app scans the QR code and connects to the bridge
-                if (data.method === "handshake") {
-                    logger_1.noLogger.debug("[frontend] Received handshake:", event.data);
-                    this.topicToRequestReceived[topic] = true;
-                    this.topicToSharedSecret[topic] = await (0, encryption_1.getSharedSecret)((0, utils_2.bytesToHex)(keyPair.privateKey), data.params.pubkey);
-                    logger_1.noLogger.debug("[frontend] Shared secret:", buffer_1.Buffer.from(this.topicToSharedSecret[topic]).toString("hex"));
-                    const encryptedMessage = await (0, json_rpc_1.createEncryptedJsonRpcRequest)("hello", null, this.topicToSharedSecret[topic], topic);
-                    logger_1.noLogger.debug("[frontend] Sending encrypted message:", encryptedMessage);
-                    wsClient.send(JSON.stringify(encryptedMessage));
-                    await Promise.all(this.onRequestReceivedCallbacks[topic].map((callback) => callback()));
-                    return;
-                }
-                // Handle encrypted messages
-                if (data.method === "encryptedMessage") {
-                    // Decode the payload from base64 to Uint8Array
-                    const payload = new Uint8Array(atob(data.params.payload)
-                        .split("")
-                        .map((c) => c.charCodeAt(0)));
-                    try {
-                        // Decrypt the payload using the shared secret
-                        const decrypted = await (0, encryption_1.decrypt)(payload, this.topicToSharedSecret[topic], topic);
-                        const decryptedJson = JSON.parse(decrypted);
-                        this.handleEncryptedMessage(topic, decryptedJson, data);
-                    }
-                    catch (error) {
-                        logger_1.noLogger.error("[frontend] Error decrypting message:", error);
-                    }
-                    return;
-                }
-            }
-            catch (error) {
-                logger_1.noLogger.error("[frontend] Error:", error);
-            }
         });
-        wsClient.onerror = (error) => {
-            logger_1.noLogger.error("[frontend] WebSocket error:", error);
-        };
+        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) {
@@ -451,6 +429,7 @@ class ZKPassport {
             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
@@ -763,6 +742,7 @@ class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         let isCorrect = true;
         const currentTime = new Date();
@@ -872,6 +852,7 @@ class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         let isCorrect = true;
         const currentTime = new Date();
@@ -975,6 +956,7 @@ class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         let isCorrect = true;
         const currentTime = new Date();
@@ -1078,6 +1060,7 @@ class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         let isCorrect = true;
         if (queryResult.nationality &&
@@ -1132,6 +1115,7 @@ class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         let isCorrect = true;
         if (queryResult.issuing_country &&
@@ -1186,6 +1170,7 @@ class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         let isCorrect = true;
         if (queryResult.nationality &&
@@ -1228,6 +1213,7 @@ class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         let isCorrect = true;
         if (queryResult.issuing_country &&
@@ -1252,13 +1238,14 @@ class ZKPassport {
         }
         return { isCorrect, queryResultErrors };
     }
-    checkScopeFromDisclosureProof(proofData, queryResultErrors, key, scope) {
+    checkScopeFromDisclosureProof(proofData, queryResultErrors, key, scope, chainId) {
         let isCorrect = true;
-        if (this.domain && (0, utils_1.getScopeHash)(this.domain) !== BigInt(proofData.publicInputs[1])) {
+        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.getScopeHash)(this.domain).toString()}`,
+                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",
             };
@@ -1302,7 +1289,52 @@ class ZKPassport {
         }
         return { isCorrect, queryResultErrors };
     }
-    async checkPublicInputs(proofs, queryResult, validity, scope) {
+    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;
@@ -1326,6 +1358,7 @@ class ZKPassport {
             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
@@ -1342,6 +1375,7 @@ class ZKPassport {
                 "inclusion_check_nationality",
                 "exclusion_check_issuing_country",
                 "inclusion_check_issuing_country",
+                "bind",
             ];
             const getIndex = (proof) => {
                 const name = proof.name || "";
@@ -1387,11 +1421,12 @@ 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)) {
+                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.getScopeHash)(this.domain).toString()}`,
+                        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",
                     };
@@ -1577,6 +1612,27 @@ class ZKPassport {
                         ...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")) {
@@ -1898,6 +1954,27 @@ class ZKPassport {
                 };
                 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 };
     }
@@ -1906,10 +1983,13 @@ class ZKPassport {
      * @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)
      * @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, devMode = false, }) {
+    async verify({ proofs, queryResult, validity, scope, evmChain, devMode = false, }) {
         // 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) {
@@ -1931,7 +2011,8 @@ class ZKPassport {
         let verified = true;
         let uniqueIdentifier;
         let queryResultErrors;
-        const { isCorrect, uniqueIdentifier: uniqueIdentifierFromPublicInputs, queryResultErrors: queryResultErrorsFromPublicInputs, } = await this.checkPublicInputs(proofs, formattedResult, validity, scope);
+        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;
@@ -2009,7 +2090,7 @@ class ZKPassport {
         if (network === "ethereum_sepolia") {
             return {
                 ...baseConfig,
-                address: "0x8c6982D77f7a8f60aE3133cA9b2FAA6f3e78c394",
+                address: "0x5e4B11F7B7995F5Cee0134692a422b045091112F",
             };
         }
         else if (network === "local_anvil") {
@@ -2102,6 +2183,14 @@ class ZKPassport {
                         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}`);
             }
@@ -2158,7 +2247,7 @@ class ZKPassport {
      * @returns The URL of the request.
      */
     getUrl(requestId) {
-        const pubkey = (0, utils_2.bytesToHex)(this.topicToKeyPair[requestId].publicKey);
+        const pubkey = this.topicToPublicKey[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");
         return `https://zkpassport.id/r?d=${this.domain}&t=${requestId}&c=${base64Config}&s=${base64Service}&p=${pubkey}&m=${this.topicToLocalConfig[requestId].mode}`;
@@ -2168,14 +2257,13 @@ class ZKPassport {
      * @param requestId The request ID.
      */
     cancelRequest(requestId) {
-        if (this.topicToWebSocketClient[requestId]) {
-            this.topicToWebSocketClient[requestId].close();
-            delete this.topicToWebSocketClient[requestId];
+        if (this.topicToBridge[requestId]) {
+            this.topicToBridge[requestId].close();
+            delete this.topicToBridge[requestId];
         }
-        delete this.topicToKeyPair[requestId];
+        delete this.topicToPublicKey[requestId];
         delete this.topicToConfig[requestId];
         delete this.topicToLocalConfig[requestId];
-        delete this.topicToSharedSecret[requestId];
         delete this.topicToProofs[requestId];
         delete this.topicToExpectedProofCount[requestId];
         delete this.topicToFailedProofCount[requestId];
@@ -2191,7 +2279,7 @@ class ZKPassport {
      * @notice Clears all requests.
      */
     clearAllRequests() {
-        for (const requestId in this.topicToWebSocketClient) {
+        for (const requestId in this.topicToBridge) {
             this.cancelRequest(requestId);
         }
     }