@zkpassport/sdk 0.3.4 → 0.4.1

package/dist/esm/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/esm/index.js

@@ -1,18 +1,14 @@
-import { randomBytes } from "crypto";
 import { getAlpha3Code, registerLocale } from "i18n-iso-countries";
-import { getProofData, getCommitmentFromDSCProof, getCommitmentInFromIDDataProof, getCommitmentOutFromIDDataProof, getNullifierFromDisclosureProof, getCommitmentInFromIntegrityProof, getCommitmentOutFromIntegrityProof, getCommitmentInFromDisclosureProof, getMerkleRootFromDSCProof, getCurrentDateFromIntegrityProof, DisclosedData, formatName, getHostedPackagedCircuitByName, getNumberOfPublicInputs, getParameterCommitmentFromDisclosureProof, getCountryParameterCommitment, getDiscloseParameterCommitment, getDateParameterCommitment, getCertificateRegistryRootFromOuterProof, getParamCommitmentsFromOuterProof, getCurrentDateFromCommittedInputs, getMinAgeFromCommittedInputs, getMaxAgeFromCommittedInputs, getAgeParameterCommitment, getMinDateFromCommittedInputs, getMaxDateFromCommittedInputs, getCurrentDateFromOuterProof, getNullifierFromOuterProof, getAgeEVMParameterCommitment, getDateEVMParameterCommitment, getDiscloseEVMParameterCommitment, getCountryEVMParameterCommitment, rightPadArrayWithZeros, getCommittedInputCount, ProofType, getScopeHash, getScopeFromOuterProof, getSubscopeFromOuterProof, } from "@zkpassport/utils";
+import { getProofData, getCommitmentFromDSCProof, getCommitmentInFromIDDataProof, getCommitmentOutFromIDDataProof, getNullifierFromDisclosureProof, getCommitmentInFromIntegrityProof, getCommitmentOutFromIntegrityProof, getCommitmentInFromDisclosureProof, getMerkleRootFromDSCProof, getCurrentDateFromIntegrityProof, DisclosedData, formatName, getHostedPackagedCircuitByName, getNumberOfPublicInputs, getParameterCommitmentFromDisclosureProof, getCountryParameterCommitment, getDiscloseParameterCommitment, getDateParameterCommitment, getCertificateRegistryRootFromOuterProof, getParamCommitmentsFromOuterProof, getCurrentDateFromCommittedInputs, getMinAgeFromCommittedInputs, getMaxAgeFromCommittedInputs, getAgeParameterCommitment, getMinDateFromCommittedInputs, getMaxDateFromCommittedInputs, getCurrentDateFromOuterProof, getNullifierFromOuterProof, getAgeEVMParameterCommitment, getDateEVMParameterCommitment, getDiscloseEVMParameterCommitment, getCountryEVMParameterCommitment, rightPadArrayWithZeros, getCommittedInputCount, ProofType, getScopeHash, getScopeFromOuterProof, getSubscopeFromOuterProof, getServiceScopeHash, getBindEVMParameterCommitment, getBindParameterCommitment, formatBoundData, } from "@zkpassport/utils";
 import { bytesToHex } from "@noble/ciphers/utils";
-import { getWebSocketClient } from "./websocket";
-import { createEncryptedJsonRpcRequest } from "./json-rpc";
-import { decrypt, generateECDHKeyPair, getSharedSecret } from "./encryption";
 import { noLogger as logger } from "./logger";
-import { inflate } from "pako";
 import i18en from "i18n-iso-countries/langs/en.json";
 import { Buffer } from "buffer/";
 import { sha256 } from "@noble/hashes/sha2";
 import { hexToBytes } from "@noble/hashes/utils";
 import ZKPassportVerifierAbi from "./assets/abi/ZKPassportVerifier.json";
 import { RegistryClient } from "@zkpassport/registry";
+import { Bridge } from "@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") {
@@ -21,6 +17,24 @@ if (typeof globalThis.Buffer === "undefined") {
         window.Buffer = 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}`);
+}
 registerLocale(i18en);
 function hasRequestedAccessToField(credentialsRequest, field) {
     const fieldValue = credentialsRequest[field];
@@ -69,9 +83,8 @@ export class ZKPassport {
     constructor(_domain) {
         this.topicToConfig = {};
         this.topicToLocalConfig = {};
-        this.topicToKeyPair = {};
-        this.topicToWebSocketClient = {};
-        this.topicToSharedSecret = {};
+        this.topicToPublicKey = {};
+        this.topicToBridge = {};
         this.topicToRequestReceived = {};
         this.topicToService = {};
         this.topicToProofs = {};
@@ -100,6 +113,9 @@ export 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];
@@ -175,6 +191,9 @@ export 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
@@ -187,7 +206,7 @@ export class ZKPassport {
      * @param request The request.
      * @param outerRequest The outer request.
      */
-    async handleEncryptedMessage(topic, request, outerRequest) {
+    async handleEncryptedMessage(topic, request) {
         logger.debug("Received encrypted message:", request);
         if (request.method === "accept") {
             logger.debug(`User accepted the request and is generating a proof`);
@@ -199,30 +218,8 @@ export class ZKPassport {
         }
         else if (request.method === "proof") {
             logger.debug(`User generated proof`);
-            // Uncompress the proof and convert it to a hex string
-            const bytesProof = Buffer.from(request.params.proof, "base64");
-            const bytesCommittedInputs = request.params.committedInputs
-                ? Buffer.from(request.params.committedInputs, "base64")
-                : null;
-            const uncompressedProof = inflate(bytesProof);
-            const uncompressedCommittedInputs = bytesCommittedInputs
-                ? 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] &&
@@ -319,10 +316,17 @@ export 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.from(JSON.stringify(this.topicToConfig[topic])).toString("base64");
                 const base64Service = Buffer.from(JSON.stringify(this.topicToService[topic])).toString("base64");
-                const pubkey = 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}`,
@@ -334,7 +338,7 @@ export 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,
                 };
             },
@@ -348,17 +352,23 @@ export 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 || randomBytes(16).toString("hex");
-        const keyPair = keyPairOverride || (await 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.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] = {
@@ -374,53 +384,21 @@ export class ZKPassport {
         this.onResultCallbacks[topic] = [];
         this.onRejectCallbacks[topic] = [];
         this.onErrorCallbacks[topic] = [];
-        const wsClient = getWebSocketClient(`wss://bridge.zkpassport.id?topic=${topic}`, this.domain);
-        this.topicToWebSocketClient[topic] = wsClient;
-        wsClient.onopen = async () => {
-            logger.info("[frontend] WebSocket connection established");
+        this.topicToPublicKey[topic] = bridge.getPublicKey();
+        this.topicToBridge[topic] = bridge;
+        bridge.onConnect(async (reconnection) => {
+            logger.debug("Bridge connected");
+            logger.debug("Is reconnection:", reconnection);
             await Promise.all(this.onBridgeConnectCallbacks[topic].map((callback) => callback()));
-        };
-        wsClient.addEventListener("message", async (event) => {
-            logger.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.debug("[frontend] Received handshake:", event.data);
-                    this.topicToRequestReceived[topic] = true;
-                    this.topicToSharedSecret[topic] = await getSharedSecret(bytesToHex(keyPair.privateKey), data.params.pubkey);
-                    logger.debug("[frontend] Shared secret:", Buffer.from(this.topicToSharedSecret[topic]).toString("hex"));
-                    const encryptedMessage = await createEncryptedJsonRpcRequest("hello", null, this.topicToSharedSecret[topic], topic);
-                    logger.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 decrypt(payload, this.topicToSharedSecret[topic], topic);
-                        const decryptedJson = JSON.parse(decrypted);
-                        this.handleEncryptedMessage(topic, decryptedJson, data);
-                    }
-                    catch (error) {
-                        logger.error("[frontend] Error decrypting message:", error);
-                    }
-                    return;
-                }
-            }
-            catch (error) {
-                logger.error("[frontend] Error:", error);
-            }
         });
-        wsClient.onerror = (error) => {
-            logger.error("[frontend] WebSocket error:", error);
-        };
+        bridge.onSecureChannelEstablished(async () => {
+            logger.debug("Secure channel established");
+            await Promise.all(this.onRequestReceivedCallbacks[topic].map((callback) => callback()));
+        });
+        bridge.onSecureMessage(async (message) => {
+            logger.debug("Received message:", message);
+            this.handleEncryptedMessage(topic, message);
+        });
         return this.getZkPassportRequest(topic);
     }
     checkDiscloseBytesPublicInputs(proof, queryResult) {
@@ -441,6 +419,7 @@ export 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
@@ -753,6 +732,7 @@ export class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         let isCorrect = true;
         const currentTime = new Date();
@@ -862,6 +842,7 @@ export class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         let isCorrect = true;
         const currentTime = new Date();
@@ -965,6 +946,7 @@ export class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         let isCorrect = true;
         const currentTime = new Date();
@@ -1068,6 +1050,7 @@ export class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         let isCorrect = true;
         if (queryResult.nationality &&
@@ -1122,6 +1105,7 @@ export class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         let isCorrect = true;
         if (queryResult.issuing_country &&
@@ -1176,6 +1160,7 @@ export class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         let isCorrect = true;
         if (queryResult.nationality &&
@@ -1218,6 +1203,7 @@ export class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         let isCorrect = true;
         if (queryResult.issuing_country &&
@@ -1242,13 +1228,14 @@ export class ZKPassport {
         }
         return { isCorrect, queryResultErrors };
     }
-    checkScopeFromDisclosureProof(proofData, queryResultErrors, key, scope) {
+    checkScopeFromDisclosureProof(proofData, queryResultErrors, key, scope, chainId) {
         let isCorrect = true;
-        if (this.domain && getScopeHash(this.domain) !== BigInt(proofData.publicInputs[1])) {
+        if (this.domain &&
+            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: ${getScopeHash(this.domain).toString()}`,
+                expected: `Scope: ${getServiceScopeHash(this.domain, chainId).toString()}`,
                 received: `Scope: ${BigInt(proofData.publicInputs[1]).toString()}`,
                 message: "The proof comes from a different domain than the one expected",
             };
@@ -1292,7 +1279,52 @@ export 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;
@@ -1316,6 +1348,7 @@ export 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
@@ -1332,6 +1365,7 @@ export class ZKPassport {
                 "inclusion_check_nationality",
                 "exclusion_check_issuing_country",
                 "inclusion_check_issuing_country",
+                "bind",
             ];
             const getIndex = (proof) => {
                 const name = proof.name || "";
@@ -1377,11 +1411,12 @@ export class ZKPassport {
                         message: "The proof does not verify all the requested conditions and information",
                     };
                 }
-                if (this.domain && getScopeHash(this.domain) !== getScopeFromOuterProof(proofData)) {
+                if (this.domain &&
+                    getServiceScopeHash(this.domain, chainId) !== getScopeFromOuterProof(proofData)) {
                     console.warn("The proof comes from a different domain than the one expected");
                     isCorrect = false;
                     queryResultErrors.outer.scope = {
-                        expected: `Scope: ${getScopeHash(this.domain).toString()}`,
+                        expected: `Scope: ${getServiceScopeHash(this.domain, chainId).toString()}`,
                         received: `Scope: ${getScopeFromOuterProof(proofData).toString()}`,
                         message: "The proof comes from a different domain than the one expected",
                     };
@@ -1567,6 +1602,27 @@ export class ZKPassport {
                         ...queryResultErrorsIssuingCountryExclusion,
                     };
                 }
+                else if (!!committedInputs?.bind) {
+                    const bindCommittedInputs = committedInputs?.bind;
+                    const bindParameterCommitment = isForEVM
+                        ? await getBindEVMParameterCommitment(formatBoundData(bindCommittedInputs.data))
+                        : await getBindParameterCommitment(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 = getNullifierFromOuterProof(proofData).toString(10);
             }
             else if (proof.name?.startsWith("sig_check_dsc")) {
@@ -1888,6 +1944,27 @@ export class ZKPassport {
                 };
                 uniqueIdentifier = getNullifierFromDisclosureProof(proofData).toString(10);
             }
+            else if (proof.name === "bind") {
+                const bindCommittedInputs = proof.committedInputs?.bind;
+                const paramCommittment = getParameterCommitmentFromDisclosureProof(proofData);
+                const calculatedParamCommitment = await getBindParameterCommitment(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 = getNullifierFromDisclosureProof(proofData).toString(10);
+            }
         }
         return { isCorrect, uniqueIdentifier, queryResultErrors };
     }
@@ -1896,10 +1973,13 @@ export 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) {
@@ -1921,7 +2001,8 @@ export 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;
@@ -1999,7 +2080,7 @@ export class ZKPassport {
         if (network === "ethereum_sepolia") {
             return {
                 ...baseConfig,
-                address: "0x8c6982D77f7a8f60aE3133cA9b2FAA6f3e78c394",
+                address: "0x5e4B11F7B7995F5Cee0134692a422b045091112F",
             };
         }
         else if (network === "local_anvil") {
@@ -2092,6 +2173,14 @@ export 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 =
+                    ProofType.BIND.toString(16).padStart(2, "0") +
+                        rightPadArrayWithZeros(formatBoundData(value.data), 500)
+                            .map((x) => x.toString(16).padStart(2, "0"))
+                            .join("");
+            }
             else {
                 throw new Error(`Unsupported circuit for EVM verification: ${circuitName}`);
             }
@@ -2148,7 +2237,7 @@ export class ZKPassport {
      * @returns The URL of the request.
      */
     getUrl(requestId) {
-        const pubkey = bytesToHex(this.topicToKeyPair[requestId].publicKey);
+        const pubkey = this.topicToPublicKey[requestId];
         const base64Config = Buffer.from(JSON.stringify(this.topicToConfig[requestId])).toString("base64");
         const base64Service = 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}`;
@@ -2158,14 +2247,13 @@ export 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];
@@ -2181,7 +2269,7 @@ export class ZKPassport {
      * @notice Clears all requests.
      */
     clearAllRequests() {
-        for (const requestId in this.topicToWebSocketClient) {
+        for (const requestId in this.topicToBridge) {
             this.cancelRequest(requestId);
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zkpassport/sdk",
-  "version": "0.3.4",
+  "version": "0.4.1",
   "description": "Privacy-preserving identity verification using passports and ID cards",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
@@ -42,8 +42,9 @@
     "@noble/ciphers": "^1.2.1",
     "@noble/hashes": "^1.7.2",
     "@noble/secp256k1": "^2.2.3",
+    "@obsidion/bridge": "^0.9.0",
     "@zkpassport/registry": "^0.1.9",
-    "@zkpassport/utils": "^0.7.4",
+    "@zkpassport/utils": "^0.9.4",
     "buffer": "^6.0.3",
     "i18n-iso-countries": "^7.12.0",
     "pako": "^2.1.0",