@zkpassport/sdk 0.3.4 → 0.4.1

package/src/index.ts

@@ -1,4 +1,3 @@
-import { randomBytes } from "crypto"
 import { Alpha3Code, getAlpha3Code, registerLocale } from "i18n-iso-countries"
 import {
   type DisclosableIDCredential,
@@ -57,11 +56,14 @@ import {
   ProofData,
   getScopeFromOuterProof,
   getSubscopeFromOuterProof,
+  getServiceScopeHash,
+  BoundData,
+  BindCommittedInputs,
+  getBindEVMParameterCommitment,
+  getBindParameterCommitment,
+  formatBoundData,
 } from "@zkpassport/utils"
 import { bytesToHex } from "@noble/ciphers/utils"
-import { getWebSocketClient, WebSocketClient } 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"
@@ -70,6 +72,7 @@ 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, BridgeInterface } from "@obsidion/bridge"
 
 const DEFAULT_DATE_VALUE = new Date(1111, 10, 11)
 
@@ -94,7 +97,8 @@ export type QueryResultErrors = {
     | "sig_check_id_data"
     | "data_check_integrity"
     | "outer"
-    | "disclose"]: {
+    | "disclose"
+    | "bind"]: {
     disclose?: QueryResultError<string | number | Date>
     gte?: QueryResultError<number | Date>
     lte?: QueryResultError<number | Date>
@@ -124,6 +128,24 @@ export type SolidityVerifierParameters = {
 
 export type EVMChain = "ethereum_sepolia" | "local_anvil"
 
+function getChainIdFromEVMChain(chain: EVMChain): number {
+  if (chain === "ethereum_sepolia") {
+    return 11155111
+  } else if (chain === "local_anvil") {
+    return 31337
+  }
+  throw new Error(`Unsupported chain: ${chain}`)
+}
+
+function getEVMChainFromChainId(chainId: number): EVMChain {
+  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: Query, field: IDCredential): boolean {
@@ -330,6 +352,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.
    *
@@ -351,13 +379,12 @@ export class ZKPassport {
       devMode: boolean
     }
   > = {}
-  private topicToKeyPair: Record<string, { privateKey: Uint8Array; publicKey: Uint8Array }> = {}
-  private topicToWebSocketClient: Record<string, WebSocketClient> = {}
-  private topicToSharedSecret: Record<string, Uint8Array> = {}
+  private topicToPublicKey: Record<string, string> = {}
+  private topicToBridge: Record<string, BridgeInterface> = {}
   private topicToRequestReceived: Record<string, boolean> = {}
   private topicToService: Record<
     string,
-    { name: string; logo: string; purpose: string; scope?: string }
+    { name: string; logo: string; purpose: string; scope?: string; chainId?: number }
   > = {}
   private topicToProofs: Record<string, Array<ProofResult>> = {}
   private topicToExpectedProofCount: Record<string, number> = {}
@@ -400,6 +427,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]
@@ -485,6 +515,9 @@ export class ZKPassport {
         }
       }
     }
+    if ((this.topicToConfig[topic] as Query).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
@@ -498,11 +531,7 @@ export class ZKPassport {
    * @param request The request.
    * @param outerRequest The outer request.
    */
-  private async handleEncryptedMessage(
-    topic: string,
-    request: JsonRpcRequest,
-    outerRequest: JsonRpcRequest,
-  ) {
+  private async handleEncryptedMessage(topic: string, request: JsonRpcRequest) {
     logger.debug("Received encrypted message:", request)
     if (request.method === "accept") {
       logger.debug(`User accepted the request and is generating a proof`)
@@ -512,31 +541,9 @@ export class ZKPassport {
       await Promise.all(this.onRejectCallbacks[topic].map((callback) => callback()))
     } 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: ProofResult = {
-        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)
+      this.topicToProofs[topic].push(request.params)
       await Promise.all(
-        this.onProofGeneratedCallbacks[topic].map((callback) => callback(processedProof)),
+        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
@@ -644,6 +651,13 @@ export class ZKPassport {
         }
         return this.getZkPassportRequest(topic)
       },
+      bind: (key: keyof BoundData, value: BoundData[keyof BoundData]) => {
+        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",
@@ -651,7 +665,7 @@ export class ZKPassport {
         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}`,
@@ -675,7 +689,7 @@ export class ZKPassport {
           onReject: (callback: () => void) => this.onRejectCallbacks[topic].push(callback),
           onError: (callback: (error: string) => void) =>
             this.onErrorCallbacks[topic].push(callback),
-          isBridgeConnected: () => this.topicToWebSocketClient[topic].readyState === WebSocket.OPEN,
+          isBridgeConnected: () => this.topicToBridge[topic].isBridgeConnected(),
           requestReceived: () => this.topicToRequestReceived[topic] === true,
         }
       },
@@ -690,6 +704,7 @@ 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.
    */
   public async request({
@@ -698,6 +713,7 @@ export class ZKPassport {
     purpose,
     scope,
     mode,
+    evmChain,
     validity,
     devMode,
     topicOverride,
@@ -708,21 +724,27 @@ export class ZKPassport {
     purpose: string
     scope?: string
     mode?: ProofMode
+    evmChain?: EVMChain
     validity?: number
     devMode?: boolean
     topicOverride?: string
     keyPairOverride?: { privateKey: Uint8Array; publicKey: Uint8Array }
   }): Promise<QueryBuilder> {
-    const topic = topicOverride || randomBytes(16).toString("hex")
+    const bridge = await Bridge.create({
+      keyPair: keyPairOverride,
+      bridgeId: topicOverride,
+    })
 
-    const keyPair = keyPairOverride || (await generateECDHKeyPair())
-    this.topicToKeyPair[topic] = {
-      privateKey: keyPair.privateKey,
-      publicKey: keyPair.publicKey,
-    }
+    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] = {
@@ -740,68 +762,22 @@ export class ZKPassport {
     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")
-      await Promise.all(this.onBridgeConnectCallbacks[topic].map((callback) => callback()))
-    }
-    wsClient.addEventListener("message", async (event: any) => {
-      logger.debug("[frontend] Received message:", event.data)
-      try {
-        const data: JsonRpcRequest = 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
-        }
+    this.topicToPublicKey[topic] = bridge.getPublicKey()
 
-        // 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: JsonRpcRequest = 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)
-      }
+    this.topicToBridge[topic] = bridge
+    bridge.onConnect(async (reconnection: boolean) => {
+      logger.debug("Bridge connected")
+      logger.debug("Is reconnection:", reconnection)
+      await Promise.all(this.onBridgeConnectCallbacks[topic].map((callback) => callback()))
+    })
+    bridge.onSecureChannelEstablished(async () => {
+      logger.debug("Secure channel established")
+      await Promise.all(this.onRequestReceivedCallbacks[topic].map((callback) => callback()))
+    })
+    bridge.onSecureMessage(async (message: any) => {
+      logger.debug("Received message:", message)
+      this.handleEncryptedMessage(topic, message)
     })
-    wsClient.onerror = (error: Event) => {
-      logger.error("[frontend] WebSocket error:", error)
-    }
     return this.getZkPassportRequest(topic)
   }
 
@@ -823,6 +799,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
@@ -1184,6 +1161,7 @@ export class ZKPassport {
       fullname: {},
       document_number: {},
       outer: {},
+      bind: {},
     }
     let isCorrect = true
     const currentTime = new Date()
@@ -1317,6 +1295,7 @@ export class ZKPassport {
       fullname: {},
       document_number: {},
       outer: {},
+      bind: {},
     }
     let isCorrect = true
     const currentTime = new Date()
@@ -1445,6 +1424,7 @@ export class ZKPassport {
       fullname: {},
       document_number: {},
       outer: {},
+      bind: {},
     }
     let isCorrect = true
     const currentTime = new Date()
@@ -1573,6 +1553,7 @@ export class ZKPassport {
       fullname: {},
       document_number: {},
       outer: {},
+      bind: {},
     }
     let isCorrect = true
     if (
@@ -1637,6 +1618,7 @@ export class ZKPassport {
       fullname: {},
       document_number: {},
       outer: {},
+      bind: {},
     }
     let isCorrect = true
 
@@ -1699,6 +1681,7 @@ export class ZKPassport {
       fullname: {},
       document_number: {},
       outer: {},
+      bind: {},
     }
     let isCorrect = true
     if (
@@ -1746,6 +1729,7 @@ export class ZKPassport {
       fullname: {},
       document_number: {},
       outer: {},
+      bind: {},
     }
     let isCorrect = true
 
@@ -1780,13 +1764,17 @@ export class ZKPassport {
     queryResultErrors: QueryResultErrors,
     key: string,
     scope?: string,
+    chainId?: number,
   ) {
     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 as keyof QueryResultErrors].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",
       }
@@ -1835,11 +1823,63 @@ export class ZKPassport {
     return { isCorrect, queryResultErrors }
   }
 
+  private checkBindPublicInputs(queryResult: QueryResult, boundData: BoundData) {
+    const queryResultErrors: 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 }
+  }
+
   private async checkPublicInputs(
     proofs: Array<ProofResult>,
     queryResult: QueryResult,
     validity?: number,
     scope?: string,
+    chainId?: number,
   ) {
     let commitmentIn: bigint | undefined
     let commitmentOut: bigint | undefined
@@ -1872,6 +1912,7 @@ export class ZKPassport {
       fullname: {},
       document_number: {},
       outer: {},
+      bind: {},
     }
 
     // Since the order is important for the commitments, we need to sort the proofs
@@ -1889,6 +1930,7 @@ export class ZKPassport {
         "inclusion_check_nationality",
         "exclusion_check_issuing_country",
         "inclusion_check_issuing_country",
+        "bind",
       ]
       const getIndex = (proof: ProofResult) => {
         const name = proof.name || ""
@@ -1945,11 +1987,14 @@ 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",
           }
@@ -2205,6 +2250,27 @@ export class ZKPassport {
             ...queryResultErrors,
             ...queryResultErrorsIssuingCountryExclusion,
           }
+        } else if (!!committedInputs?.bind) {
+          const bindCommittedInputs = committedInputs?.bind as BindCommittedInputs
+          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")) {
@@ -2636,6 +2702,29 @@ export class ZKPassport {
           ...queryResultErrorsScope,
         }
         uniqueIdentifier = getNullifierFromDisclosureProof(proofData).toString(10)
+      } else if (proof.name === "bind") {
+        const bindCommittedInputs = proof.committedInputs?.bind as BindCommittedInputs
+        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 }
@@ -2646,6 +2735,9 @@ 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.
    */
@@ -2654,12 +2746,14 @@ export class ZKPassport {
     queryResult,
     validity,
     scope,
+    evmChain,
     devMode = false,
   }: {
     proofs: Array<ProofResult>
     queryResult: QueryResult
     validity?: number
     scope?: string
+    evmChain?: EVMChain
     devMode?: boolean
   }): Promise<{
     uniqueIdentifier: string | undefined
@@ -2692,11 +2786,12 @@ export class ZKPassport {
     let verified = true
     let uniqueIdentifier: string | undefined
     let queryResultErrors: QueryResultErrors | undefined
+    const chainId = evmChain ? getChainIdFromEVMChain(evmChain) : undefined
     const {
       isCorrect,
       uniqueIdentifier: uniqueIdentifierFromPublicInputs,
       queryResultErrors: queryResultErrorsFromPublicInputs,
-    } = await this.checkPublicInputs(proofs, formattedResult, validity, scope)
+    } = await this.checkPublicInputs(proofs, formattedResult, validity, scope, chainId)
     uniqueIdentifier = uniqueIdentifierFromPublicInputs
     verified = isCorrect
     queryResultErrors = isCorrect ? undefined : queryResultErrorsFromPublicInputs
@@ -2790,7 +2885,7 @@ export class ZKPassport {
     if (network === "ethereum_sepolia") {
       return {
         ...baseConfig,
-        address: "0x8c6982D77f7a8f60aE3133cA9b2FAA6f3e78c394",
+        address: "0x5e4B11F7B7995F5Cee0134692a422b045091112F",
       }
     } else if (network === "local_anvil") {
       return {
@@ -2901,6 +2996,13 @@ export class ZKPassport {
           ProofType.DISCLOSE.toString(16).padStart(2, "0") +
           value.discloseMask.map((x) => x.toString(16).padStart(2, "0")).join("") +
           value.disclosedBytes.map((x) => x.toString(16).padStart(2, "0")).join("")
+      } else if (circuitName === "bind_evm") {
+        const value = proof.committedInputs[circuitName] as BindCommittedInputs
+        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}`)
       }
@@ -2959,7 +3061,7 @@ export class ZKPassport {
    * @returns The URL of the request.
    */
   public getUrl(requestId: string) {
-    const pubkey = bytesToHex(this.topicToKeyPair[requestId].publicKey)
+    const pubkey = this.topicToPublicKey[requestId]
     const base64Config = Buffer.from(JSON.stringify(this.topicToConfig[requestId])).toString(
       "base64",
     )
@@ -2974,14 +3076,13 @@ export class ZKPassport {
    * @param requestId The request ID.
    */
   public cancelRequest(requestId: string) {
-    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]
@@ -2998,7 +3099,7 @@ export class ZKPassport {
    * @notice Clears all requests.
    */
   public clearAllRequests() {
-    for (const requestId in this.topicToWebSocketClient) {
+    for (const requestId in this.topicToBridge) {
       this.cancelRequest(requestId)
     }
   }