@zkpassport/sdk 0.3.3 → 0.4.0

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];
@@ -197,7 +213,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 +225,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] &&
@@ -332,7 +326,7 @@ class ZKPassport {
             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 +338,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 +352,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 +384,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) {
@@ -1252,13 +1220,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 +1271,7 @@ class ZKPassport {
         }
         return { isCorrect, queryResultErrors };
     }
-    async checkPublicInputs(proofs, queryResult, validity, scope) {
+    async checkPublicInputs(proofs, queryResult, validity, scope, chainId) {
         let commitmentIn;
         let commitmentOut;
         let isCorrect = true;
@@ -1387,11 +1356,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",
                     };
@@ -1906,10 +1876,21 @@ 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) {
+            return {
+                uniqueIdentifier: undefined,
+                verified: false,
+            };
+        }
         const formattedResult = queryResult;
         // Make sure to reconvert the dates to Date objects
         if (formattedResult.birthdate && formattedResult.birthdate.disclose) {
@@ -1923,7 +1904,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;
@@ -2001,7 +1983,7 @@ class ZKPassport {
         if (network === "ethereum_sepolia") {
             return {
                 ...baseConfig,
-                address: "0x8c6982D77f7a8f60aE3133cA9b2FAA6f3e78c394",
+                address: "0xDfE02DFd5c208854884B58bFf6522De5c42F73E3",
             };
         }
         else if (network === "local_anvil") {
@@ -2150,7 +2132,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}`;
@@ -2160,14 +2142,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];
@@ -2183,7 +2164,7 @@ class ZKPassport {
      * @notice Clears all requests.
      */
     clearAllRequests() {
-        for (const requestId in this.topicToWebSocketClient) {
+        for (const requestId in this.topicToBridge) {
             this.cancelRequest(requestId);
         }
     }