@zkpassport/sdk 0.4.0 → 0.4.1

package/dist/cjs/index.d.ts

@@ -1,11 +1,11 @@
-import { type DisclosableIDCredential, type IDCredential, type IDCredentialValue, type NumericalIDCredential, type ProofResult, type QueryResult, ProofMode } from "@zkpassport/utils";
+import { type DisclosableIDCredential, type IDCredential, type IDCredentialValue, type NumericalIDCredential, type ProofResult, type QueryResult, ProofMode, BoundData } from "@zkpassport/utils";
 export type QueryResultError<T> = {
     expected?: T;
     received?: T;
     message: string;
 };
 export type QueryResultErrors = {
-    [key in IDCredential | "sig_check_dsc" | "sig_check_id_data" | "data_check_integrity" | "outer" | "disclose"]: {
+    [key in IDCredential | "sig_check_dsc" | "sig_check_id_data" | "data_check_integrity" | "outer" | "disclose" | "bind"]: {
         disclose?: QueryResultError<string | number | Date>;
         gte?: QueryResultError<number | Date>;
         lte?: QueryResultError<number | Date>;
@@ -150,6 +150,12 @@ export type QueryBuilder = {
      * @param key The attribute to disclose.
      */
     disclose: (key: DisclosableIDCredential) => QueryBuilder;
+    /**
+     * Binds a value to the request.
+     * @param key The key of the value to bind.
+     * @param value The value to bind the request to.
+     */
+    bind: (key: keyof BoundData, value: BoundData[keyof BoundData]) => QueryBuilder;
     /**
      * Builds the request.
      *
@@ -224,6 +230,7 @@ export declare class ZKPassport {
     private checkIssuingCountryInclusionPublicInputs;
     private checkScopeFromDisclosureProof;
     private checkCertificateRegistryRoot;
+    private checkBindPublicInputs;
     private checkPublicInputs;
     /**
      * @notice Verify the proofs received from the mobile app.

package/dist/cjs/index.js

@@ -201,6 +201,9 @@ class ZKPassport {
                 }
             }
         }
+        if (this.topicToConfig[topic].bind) {
+            neededCircuits.push("bind");
+        }
         // From the circuits needed, determine the expected proof count
         // There are at least 4 proofs, 3 base proofs and 1 disclosure proof minimum
         // Each separate needed circuit adds 1 disclosure proof
@@ -323,6 +326,13 @@ 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");
@@ -419,6 +429,7 @@ class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         let isCorrect = true;
         // We can't be certain that the disclosed data is for a passport or an ID card
@@ -731,6 +742,7 @@ class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         let isCorrect = true;
         const currentTime = new Date();
@@ -840,6 +852,7 @@ class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         let isCorrect = true;
         const currentTime = new Date();
@@ -943,6 +956,7 @@ class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         let isCorrect = true;
         const currentTime = new Date();
@@ -1046,6 +1060,7 @@ class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         let isCorrect = true;
         if (queryResult.nationality &&
@@ -1100,6 +1115,7 @@ class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         let isCorrect = true;
         if (queryResult.issuing_country &&
@@ -1154,6 +1170,7 @@ class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         let isCorrect = true;
         if (queryResult.nationality &&
@@ -1196,6 +1213,7 @@ class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         let isCorrect = true;
         if (queryResult.issuing_country &&
@@ -1271,6 +1289,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 +1358,7 @@ class ZKPassport {
             fullname: {},
             document_number: {},
             outer: {},
+            bind: {},
         };
         // Since the order is important for the commitments, we need to sort the proofs
         // by their expected order: root signature check -> ID signature check -> integrity check -> disclosure
@@ -1311,6 +1375,7 @@ class ZKPassport {
                 "inclusion_check_nationality",
                 "exclusion_check_issuing_country",
                 "inclusion_check_issuing_country",
+                "bind",
             ];
             const getIndex = (proof) => {
                 const name = proof.name || "";
@@ -1547,6 +1612,27 @@ class ZKPassport {
                         ...queryResultErrorsIssuingCountryExclusion,
                     };
                 }
+                else if (!!committedInputs?.bind) {
+                    const bindCommittedInputs = committedInputs?.bind;
+                    const bindParameterCommitment = isForEVM
+                        ? await (0, utils_1.getBindEVMParameterCommitment)((0, utils_1.formatBoundData)(bindCommittedInputs.data))
+                        : await (0, utils_1.getBindParameterCommitment)((0, utils_1.formatBoundData)(bindCommittedInputs.data));
+                    if (!paramCommitments.includes(bindParameterCommitment)) {
+                        console.warn("This proof does not verify the bound data");
+                        isCorrect = false;
+                        queryResultErrors.bind.commitment = {
+                            expected: `Bind parameter commitment: ${bindParameterCommitment.toString()}`,
+                            received: `Parameter commitments included: ${paramCommitments.join(", ")}`,
+                            message: "This proof does not verify the bound data",
+                        };
+                    }
+                    const { isCorrect: isCorrectBind, queryResultErrors: queryResultErrorsBind } = this.checkBindPublicInputs(queryResult, bindCommittedInputs.data);
+                    isCorrect = isCorrect && isCorrectBind;
+                    queryResultErrors = {
+                        ...queryResultErrors,
+                        ...queryResultErrorsBind,
+                    };
+                }
                 uniqueIdentifier = (0, utils_1.getNullifierFromOuterProof)(proofData).toString(10);
             }
             else if (proof.name?.startsWith("sig_check_dsc")) {
@@ -1868,6 +1954,27 @@ class ZKPassport {
                 };
                 uniqueIdentifier = (0, utils_1.getNullifierFromDisclosureProof)(proofData).toString(10);
             }
+            else if (proof.name === "bind") {
+                const bindCommittedInputs = proof.committedInputs?.bind;
+                const paramCommittment = (0, utils_1.getParameterCommitmentFromDisclosureProof)(proofData);
+                const calculatedParamCommitment = await (0, utils_1.getBindParameterCommitment)((0, utils_1.formatBoundData)(bindCommittedInputs.data));
+                if (paramCommittment !== calculatedParamCommitment) {
+                    console.warn("The bound data does not match the one from the proof");
+                    isCorrect = false;
+                    queryResultErrors.bind.commitment = {
+                        expected: `Commitment: ${calculatedParamCommitment}`,
+                        received: `Commitment: ${paramCommittment}`,
+                        message: "The bound data does not match the one from the proof",
+                    };
+                }
+                const { isCorrect: isCorrectBind, queryResultErrors: queryResultErrorsBind } = this.checkBindPublicInputs(queryResult, bindCommittedInputs.data);
+                isCorrect = isCorrect && isCorrectBind;
+                queryResultErrors = {
+                    ...queryResultErrors,
+                    ...queryResultErrorsBind,
+                };
+                uniqueIdentifier = (0, utils_1.getNullifierFromDisclosureProof)(proofData).toString(10);
+            }
         }
         return { isCorrect, uniqueIdentifier, queryResultErrors };
     }
@@ -1983,7 +2090,7 @@ class ZKPassport {
         if (network === "ethereum_sepolia") {
             return {
                 ...baseConfig,
-                address: "0xDfE02DFd5c208854884B58bFf6522De5c42F73E3",
+                address: "0x5e4B11F7B7995F5Cee0134692a422b045091112F",
             };
         }
         else if (network === "local_anvil") {
@@ -2076,6 +2183,14 @@ class ZKPassport {
                         value.discloseMask.map((x) => x.toString(16).padStart(2, "0")).join("") +
                         value.disclosedBytes.map((x) => x.toString(16).padStart(2, "0")).join("");
             }
+            else if (circuitName === "bind_evm") {
+                const value = proof.committedInputs[circuitName];
+                compressedCommittedInputs =
+                    utils_1.ProofType.BIND.toString(16).padStart(2, "0") +
+                        (0, utils_1.rightPadArrayWithZeros)((0, utils_1.formatBoundData)(value.data), 500)
+                            .map((x) => x.toString(16).padStart(2, "0"))
+                            .join("");
+            }
             else {
                 throw new Error(`Unsupported circuit for EVM verification: ${circuitName}`);
             }