@zkpassport/sdk 0.4.0 → 0.4.2

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.
      *
@@ -199,7 +205,7 @@ export declare class ZKPassport {
      * @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, evmChain, validity, devMode, topicOverride, keyPairOverride, }: {
+    request({ name, logo, purpose, scope, mode, evmChain, validity, devMode, topicOverride, keyPairOverride, cloudProverUrl, bridgeUrl, }: {
         name: string;
         logo: string;
         purpose: string;
@@ -213,6 +219,8 @@ export declare class ZKPassport {
             privateKey: Uint8Array;
             publicKey: Uint8Array;
         };
+        cloudProverUrl?: string;
+        bridgeUrl?: string;
     }): Promise<QueryBuilder>;
     private checkDiscloseBytesPublicInputs;
     private checkAgePublicInputs;
@@ -224,6 +232,7 @@ export declare class ZKPassport {
     private checkIssuingCountryInclusionPublicInputs;
     private checkScopeFromDisclosureProof;
     private checkCertificateRegistryRoot;
+    private checkBindPublicInputs;
     private checkPublicInputs;
     /**
      * @notice Verify the proofs received from the mobile app.
@@ -273,6 +282,7 @@ export declare class ZKPassport {
         scope?: string;
         devMode?: boolean;
     }): SolidityVerifierParameters;
+    private _getUrl;
     /**
      * @notice Returns the URL of the request.
      * @param requestId The request ID.

package/dist/cjs/index.js

@@ -13,6 +13,7 @@ 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 VERSION = "0.4.2";
 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") {
@@ -201,6 +202,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
@@ -323,13 +327,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 = 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}`,
+                    url: this._getUrl(topic),
                     requestId: topic,
                     onRequestReceived: (callback) => this.onRequestReceivedCallbacks[topic].push(callback),
                     onGeneratingProof: (callback) => this.onGeneratingProofCallbacks[topic].push(callback),
@@ -355,10 +363,11 @@ class ZKPassport {
      * @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, evmChain, validity, devMode, topicOverride, keyPairOverride, }) {
+    async request({ name, logo, purpose, scope, mode, evmChain, validity, devMode, topicOverride, keyPairOverride, cloudProverUrl, bridgeUrl, }) {
         const bridge = await bridge_1.Bridge.create({
             keyPair: keyPairOverride,
             bridgeId: topicOverride,
+            bridgeUrl,
         });
         const topic = bridge.connection.getBridgeId();
         this.topicToConfig[topic] = {};
@@ -368,6 +377,8 @@ class ZKPassport {
             purpose,
             scope,
             chainId: evmChain ? getChainIdFromEVMChain(evmChain) : undefined,
+            cloudProverUrl,
+            bridgeUrl,
         };
         this.topicToProofs[topic] = [];
         this.topicToExpectedProofCount[topic] = 0;
@@ -419,6 +430,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
@@ -731,6 +743,7 @@ class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         let isCorrect = true;
         const currentTime = new Date();
@@ -840,6 +853,7 @@ class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         let isCorrect = true;
         const currentTime = new Date();
@@ -943,6 +957,7 @@ class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         let isCorrect = true;
         const currentTime = new Date();
@@ -1046,6 +1061,7 @@ class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         let isCorrect = true;
         if (queryResult.nationality &&
@@ -1100,6 +1116,7 @@ class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         let isCorrect = true;
         if (queryResult.issuing_country &&
@@ -1154,6 +1171,7 @@ class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         let isCorrect = true;
         if (queryResult.nationality &&
@@ -1196,6 +1214,7 @@ class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         let isCorrect = true;
         if (queryResult.issuing_country &&
@@ -1271,6 +1290,51 @@ class ZKPassport {
         }
         return { isCorrect, queryResultErrors };
     }
+    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;
@@ -1295,6 +1359,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
@@ -1311,6 +1376,7 @@ class ZKPassport {
                 "inclusion_check_nationality",
                 "exclusion_check_issuing_country",
                 "inclusion_check_issuing_country",
+                "bind",
             ];
             const getIndex = (proof) => {
                 const name = proof.name || "";
@@ -1547,6 +1613,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")) {
@@ -1868,6 +1955,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 };
     }
@@ -1983,7 +2091,7 @@ class ZKPassport {
         if (network === "ethereum_sepolia") {
             return {
                 ...baseConfig,
-                address: "0xDfE02DFd5c208854884B58bFf6522De5c42F73E3",
+                address: "0x5e4B11F7B7995F5Cee0134692a422b045091112F",
             };
         }
         else if (network === "local_anvil") {
@@ -2076,6 +2184,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}`);
             }
@@ -2126,16 +2242,19 @@ class ZKPassport {
         };
         return params;
     }
+    _getUrl(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");
+        const pubkey = this.topicToPublicKey[requestId];
+        return `https://zkpassport.id/r?d=${this.domain}&t=${requestId}&c=${base64Config}&s=${base64Service}&p=${pubkey}&m=${this.topicToLocalConfig[requestId].mode}&v=${VERSION}`;
+    }
     /**
      * @notice Returns the URL of the request.
      * @param requestId The request ID.
      * @returns The URL of the request.
      */
     getUrl(requestId) {
-        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}`;
+        return this._getUrl(requestId);
     }
     /**
      * @notice Cancels a request by closing the WebSocket connection and deleting the associated data.