Delivered: Your Amazon.com order #111-3061760-=
+5513056͏ ͏ =
+͏ ͏ ͏ =
+ ͏ ͏ =
+ ͏ ͏ =
+ ͏ ͏ =
+ ͏ ͏ &=
+#847; ͏ ͏ &=
+zwnj; ͏ ͏ &=
+nbsp; ͏ ͏ &=
+#8199; ͏ ͏ =
+͏ ͏ &#=
+847; ͏ ͏ &z=
+wnj; ͏ ͏ &n=
+bsp; ͏ ͏ &#=
+8199; ͏ ͏ &=
+shy;͏ ͏ =
+47; ͏ ͏ &zw=
+nj; ͏ ͏ &nb=
+sp; ͏ ͏ =
+199; ͏ ͏ &s=
+hy;͏ ͏ T=
+7; ͏ ͏ &zwn=
+j; ͏ ͏ &nbs=
+p; ͏ ͏ Q=
+99; ͏ ͏ &sh=
+y;͏ ͏ ͏=
+; ͏ ͏ &zwnj=
+; ͏ ͏ =
+; ͏ ͏ ̳=
+9; ͏ ͏ =
+;͏ ͏ ͏=
+ ͏ ͏ =
+ ͏ ͏ =
+ ͏ ͏ =
+; ͏ ͏ =
+͏ ͏ ͏ =
+ ͏ ͏ =
+ ͏ ͏ =
+ ͏ ͏ =
+ ͏ ͏ &=
+#847; ͏ ͏ &=
+zwnj; ͏ ͏ &=
+nbsp; ͏ ͏ &=
+#8199; ͏ ͏ =
+͏ ͏ &#=
+847; ͏ ͏ &z=
+wnj; ͏ ͏ &n=
+bsp; ͏ ͏ &#=
+8199; ͏ ͏ &=
+shy;͏ ͏ =
+47; ͏ ͏ &zw=
+nj; ͏ ͏ &nb=
+sp; ͏ ͏ =
+199; ͏ ͏ &s=
+hy;͏ ͏ T=
+7; ͏ ͏ &zwn=
+j; ͏ ͏ &nbs=
+p; ͏ ͏ Q=
+99; ͏ ͏ &sh=
+y;͏ ͏ ͏=
+; ͏ ͏ &zwnj=
+; ͏ ͏ =
+; ͏ ͏ ̳=
+9; ͏ ͏ =
+;͏ ͏ ͏=
+ ͏ ͏ =
+ ͏ ͏ =
+ ͏ ͏ =
+;
=
+
<=
+/div>
Your package has been deli=
+vered to reception.
=
+
=
+ =
+
=
+
Order #
111-30=
+61760-5513056
<=
+td style=3D"direction:ltr;font-size:0px;padding:0;text-align:left;">
+------=_Part_533333_1464710557.1723770094034--
diff --git a/browser_test/public/vite.svg b/browser_test/public/vite.svg
new file mode 100644
index 0000000..e7b8dfb
--- /dev/null
+++ b/browser_test/public/vite.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/browser_test/public/x.eml b/browser_test/public/x.eml
new file mode 100644
index 0000000..75be0c0
--- /dev/null
+++ b/browser_test/public/x.eml
@@ -0,0 +1,405 @@
+Delivered-To: thezdev1@gmail.com
+Received: by 2002:a05:7208:30c4:b0:a0:251d:5e41 with SMTP id e4csp175734rba;
+ Thu, 19 Jun 2025 04:11:00 -0700 (PDT)
+X-Google-Smtp-Source: AGHT+IEqIGdeTfkTaA0FmCe08u7/OD8Ru1LUIIFHoRSiZxPbItCCdKY7agF6+p8yWEJPI2YH1evl
+X-Received: by 2002:a05:6a00:10c8:b0:748:2ff7:5e22 with SMTP id d2e1a72fcca58-7489cff1950mr24545143b3a.10.1750331459999;
+ Thu, 19 Jun 2025 04:10:59 -0700 (PDT)
+ARC-Seal: i=1; a=rsa-sha256; t=1750331459; cv=none;
+ d=google.com; s=arc-20240605;
+ b=YGPxlFL/PE8FcA3Mm5VMS/Yqny5nXI+ic/pyxui4FvcTQt5Fgrb55rzAmUy1pXWdj6
+ 3i3bwwAL6Ey4wUmaIVHdopLeYdLF9z/u7qZKE7/ZSJxMTFFV3UBQeyuzY0NzTAoIkCYD
+ liYFdggZb28ELmc4o/KuHTSVZZjN/+4d/MtFAspW3O8CfbpL7hksdCyHpzP/cD3s5ywq
+ NQ1uFvp6LJ9RWe1h8w1mjdWJQH3ppXGc6NkJ+e27/0g9FKFU3u0kW+kbV61QAWuoQPw7
+ g7fhIm6ffL3KqEDK8yIIi3/ap+Ra6RTfhoEG5/cRaDpJjjAlSBofQY2V9Hhpe0sKlfUl
+ nylg==
+ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20240605;
+ h=feedback-id:message-id:mime-version:subject:to:from:date
+ :dkim-signature;
+ bh=nQMuQW5OYEIjDAZsqKnZrCfouvj0Gwod2TU3Wsd+et0=;
+ fh=fDYYgXivSc6zTOFPhUG2MdKnqwapTBkpVsOysAWOq8A=;
+ b=cWk0anbItsupTlJoWMOBg40BECJeiX0hTlpE2qM1g/FdYfioEX1YLwhftUmdfinJn8
+ L3WEHf4PI6zKs9fU3oVick6x1YZwLoDV3auVuseco/f0JDhtsJo18sLM60HfnqD/r1d9
+ DgSjcqEPv6YNqiFgGz89G1ZslNAg9egH4ex3ovvEybVYrMgnYZZzRCrLkzKxpd6mMYtv
+ XbTTc0OAADSVplnyou8tvw7tk2taM6erPZ0/6S+N3jkC4Uh90lNWNOVo/pTwDI7J4e4r
+ JCLHoKENpCmugckKdQm4Et9CnQnaFa3QWHD6DZKiyDB4/7jHXguJ9d+L87hrDz3PuW45
+ XEHQ==;
+ dara=google.com
+ARC-Authentication-Results: i=1; mx.google.com;
+ dkim=pass header.i=@x.com header.s=dkim-202308 header.b=F8Ci42hm;
+ spf=pass (google.com: domain of n0258ffc1a1-b6fb81bb1b404dab-thezdev1===gmail.com@bounce.x.com designates 199.59.150.95 as permitted sender) smtp.mailfrom="n0258ffc1a1-b6fb81bb1b404dab-thezdev1===gmail.com@bounce.x.com";
+ dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=x.com
+Return-Path:
+Received: from spruce-goose-az.x.com (spruce-goose-az.x.com. [199.59.150.95])
+ by mx.google.com with ESMTPS id d2e1a72fcca58-748900de9eesi20528550b3a.117.2025.06.19.04.10.59
+ for
+ (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128);
+ Thu, 19 Jun 2025 04:10:59 -0700 (PDT)
+Received-SPF: pass (google.com: domain of n0258ffc1a1-b6fb81bb1b404dab-thezdev1===gmail.com@bounce.x.com designates 199.59.150.95 as permitted sender) client-ip=199.59.150.95;
+Authentication-Results: mx.google.com;
+ dkim=pass header.i=@x.com header.s=dkim-202308 header.b=F8Ci42hm;
+ spf=pass (google.com: domain of n0258ffc1a1-b6fb81bb1b404dab-thezdev1===gmail.com@bounce.x.com designates 199.59.150.95 as permitted sender) smtp.mailfrom="n0258ffc1a1-b6fb81bb1b404dab-thezdev1===gmail.com@bounce.x.com";
+ dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=x.com
+DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=x.com;
+ s=dkim-202308; t=1750331459;
+ bh=nQMuQW5OYEIjDAZsqKnZrCfouvj0Gwod2TU3Wsd+et0=;
+ h=Date:From:To:Subject:MIME-Version:Content-Type:Message-ID;
+ b=F8Ci42hmXmjWJsrA/puFKvSDEZg4bW10y7GxnTZGUTUu1eYCIV/jY9+2wNwUt/3xv
+ IU3mvOfxz+4doWpPankDNrd5nKqQLcqojk4j9WKp6AUpEb6k2wtbI2ts1571SORS7T
+ uoIcDqYYnG4xgctA6WAFq4GVPVz/9b66T10h+7hh3m94TGTsyhxbnlmG9Bynh9dzwv
+ EJSklFxBxvMddm8xl/SPqS1qldaXPPIJciqnL8jutY+FKr3FohdA8aGJW4XghtsK1k
+ 4cCFQypXk7Lt2LzMemKVL3uF3q6ijiH3g0vm0lNH+QDTLIcBDB0CyESKrcZU9KY0Z2
+ Rr95PUd7VXpIw==
+X-MSFBL: grhyOKQTvtsYESUktMBBQURsL6vKGauN1dR6VHDnwDA=|eyJnIjoiQnVsayIsImI
+ iOiJwZHhhLWF4ZC0yMy1zcjEtQnVsay4yMjEiLCJyIjoidGhlemRldjFAZ21haWw
+ uY29tIiwidSI6InRoZXpkZXYxQGdtYWlsLmNvbUBpaWQjI2I2ZmI4MWJiMWI0MDR
+ kYWJiMWY2ZGUzOTEzNWI4MDQ0QHVzYiMjMjRAMjk2QDE5MzU2NTYyMTcwODQ1ODg
+ wMzJAMEA4ZDcyMDgwYTNhNTFkM2M3MmJmZWY2MjVmYjEzODcyYjQ1NWQ4NTYwIn0
+ =
+Date: Thu, 19 Jun 2025 11:10:59 +0000
+From: X
+To: zdev
+Subject: Password reset request
+MIME-Version: 1.0
+Content-Type: multipart/alternative;
+ boundary="----=_Part_2136046_1004234415.1750331459121"
+X-Twitter-CID: ibis2-password_reset_pin_based_email
+Message-ID: <64.97.52056.340F3586@x.com>
+Feedback-ID: pdxa.c5bbd1c7e491b5023ff4b22a03711997:X
+
+------=_Part_2136046_1004234415.1750331459121
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 7bit
+
+X
+
+Reset your password?
+
+If you requested a password reset for thezdev1, use the confirmation code below to complete the process. If you didn't make this request, ignore this email.
+
+> 87i8ar3c
+
+
+Getting a lot of password reset emails?
+You can change your account settings to require personal information to reset your password.
+
+account settings
+> https://x.com/settings/security
+
+------------------------
+Help
+> https://support.x.com/articles/14663
+
+Not my account
+> https://twitter.com/account/not_my_account/1935656217084588032/8G556-G5A82-175033?ut=1&cn=cGFzc3dvcmRfcmVzZXRfcGluX2Jhc2VkX2VtYWls
+
+Email security tips
+> https://help.x.com/safety-and-security/fake-x-emails
+
+X Corp. 1355 Market Street, Suite 900 San Francisco, CA 94103
+
+------=_Part_2136046_1004234415.1750331459121
+Content-Type: text/html; charset=UTF-8
+Content-Transfer-Encoding: quoted-printable
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+------=_Part_2136046_1004234415.1750331459121--
diff --git a/browser_test/src/main.ts b/browser_test/src/main.ts
new file mode 100644
index 0000000..f6e0985
--- /dev/null
+++ b/browser_test/src/main.ts
@@ -0,0 +1,15 @@
+import "./style.css";
+import { setupNoirProver } from "./noirProver.ts";
+
+document.querySelector("#app")!.innerHTML = `
+
+
ZK Email SDK Browser Test
+
+
("#noir-prover")!);
diff --git a/browser_test/src/noirProver.ts b/browser_test/src/noirProver.ts
new file mode 100644
index 0000000..3d04185
--- /dev/null
+++ b/browser_test/src/noirProver.ts
@@ -0,0 +1,263 @@
+import zkeSdk, { DecomposedRegex, ExternalInput, ExternalInputInput, ExternalInputProof, PublicProofData } from "@zk-email/sdk";
+import { initNoirWasm } from "@zk-email/sdk/initNoirWasm";
+import { init, generateNoirCircuitInputsWithRegexesAndExternalInputs, parseEmail } from "../../pkg/relayer_utils.js";
+
+export function setupNoirProver(element: HTMLElement) {
+ const sdk = zkeSdk({
+ baseUrl: "https://staging-conductor.zk.email",
+ logging: { enabled: true, level: "debug" },
+ });
+ // const sdk = zkeSdk({
+ // baseUrl: "http://127.0.0.1:8080",
+ // logging: { enabled: true, level: "debug" },
+ // });
+ // const sdk = zkeSdk({ baseUrl: "https://dev-conductor.zk.email" });
+
+ const proveButton = element.querySelector("button");
+ if (proveButton) {
+ proveButton.addEventListener("click", async () => {
+ try {
+ console.log("getting blueprint");
+ // const blueprint = await sdk.getBlueprintById("4c67a6fe-6202-40ff-8672-9dbe02e5cb52");
+ const blueprint = await sdk.getBlueprintById("1efb18f3-c0f7-44e5-95dd-38059cc0004a");
+
+ console.log("blueprint: ", blueprint);
+
+ const prover = blueprint.createProver({ isLocal: true });
+ console.log("prover");
+ console.log("typeof prover", typeof prover);
+
+ const eml = await getEml();
+
+ try {
+ const isValidEml = await blueprint.validateEmail(eml!);
+ console.log("isValidEml: ", isValidEml);
+ } catch (err) {
+ console.error("Email is not valid: ", err);
+ }
+
+ const { Noir, UltraHonkBackend } = await initNoirWasm();
+
+ // Initialize relayer-utils WASM
+ await init();
+
+ const parsedEmail = await parseEmail(eml!);
+
+ const circuit = await blueprint.getNoirCircuit();
+ const regexGraphs = await blueprint.getNoirRegexGraphs();
+
+ const regexInputs = blueprint.props.decomposedRegexes.map((dr) => {
+ const regexGraph = regexGraphs[`${dr.name}_regex.json`];
+ if (!regexGraph) {
+ throw new Error(`No regexGraph was compiled for decomposedRegexe ${dr.name}`);
+ }
+
+ let haystack_location;
+ if (dr.location === "header") {
+ haystack_location = "Header";
+ } else {
+ haystack_location = "Body";
+ }
+
+ const maxHaystackLength =
+ dr.location === "header"
+ ? blueprint.props.emailHeaderMaxLength
+ : blueprint.props.emailBodyMaxLength;
+
+ return {
+ name: dr.name,
+ regex_graph_json: JSON.stringify(regexGraph),
+ haystack_location,
+ max_haystack_length: maxHaystackLength,
+ max_match_length: dr.maxLength,
+ proving_framework: "noir",
+ };
+ });
+
+ const noirParams = {
+ maxHeaderLength: blueprint.props.emailHeaderMaxLength || 512,
+ maxBodyLength: blueprint.props.emailBodyMaxLength || 0,
+ ignoreBodyHashCheck: blueprint.props.ignoreBodyHashCheck,
+ removeSoftLineBreaks: blueprint.props.removeSoftLinebreaks,
+ shaPrecomputeSelector: blueprint.props.shaPrecomputeSelector,
+ proverEthAddress: "0x0000000000000000000000000000000000000000",
+ };
+
+ console.log("generating inputs regexInputs: ", regexInputs);
+ // console.log("generating inputs externalInputs: ", externalInputs);
+ console.log("generating inputs noirParams: ", noirParams);
+
+ const externalInputsWithMaxLength = addMaxLengthToExternalInputs(
+ [],
+ blueprint.props.externalInputs
+ );
+
+ console.log("externalInputsWithMaxLength: ", externalInputsWithMaxLength);
+
+ const circuitInputs = await generateNoirCircuitInputsWithRegexesAndExternalInputs(
+ eml,
+ regexInputs,
+ externalInputsWithMaxLength,
+ noirParams
+ );
+ console.log("circuitInputs: ", circuitInputs);
+
+ if (!circuitInputs) {
+ throw new Error("Could not generate circuit inputs for noir");
+ }
+
+ const compiledProgram = circuit as any;
+
+ const noir = new Noir(compiledProgram);
+ // TODO: we can use threads here, although not defining threads is the same speed
+ // const backend = new UltraHonkBackend(circuit.bytecode, threads ? { threads } : {});
+ const backend = new UltraHonkBackend(compiledProgram.bytecode);
+
+ // Convert from Map to object
+ const circuitInputsObject: any = {};
+ for (const [key, value] of circuitInputs) {
+ if (value && typeof value === "object" && value instanceof Map) {
+ circuitInputsObject[key] = Object.fromEntries(value);
+ } else if (value) {
+ circuitInputsObject[key] = value;
+ }
+ }
+
+ console.log("circuitInputsObject: ", circuitInputsObject);
+ // delete circuitInputsObject.dkim_header_sequence;
+
+ console.time("witness");
+ const { witness } = await noir.execute(circuitInputsObject);
+ console.timeEnd("witness");
+
+ console.time("prove");
+ const proof = await backend.generateProof(witness);
+ console.timeEnd("prove");
+
+ const { publicData, externalInputsProof } = parseNoirPublicOutputs(
+ proof.publicInputs,
+ blueprint.props.decomposedRegexes,
+ blueprint.props.externalInputs,
+ externalInputsWithMaxLength
+ );
+
+ console.log("publicData: ", publicData);
+ console.log("externalInputsProof: ", externalInputsProof);
+
+ } catch (err) {
+ console.error("Failed to prove: ", err);
+ }
+ });
+ }
+}
+
+async function getEml() {
+ try {
+ const response = await fetch("/amazon.eml"); // URL is relative to the root of the project
+ if (!response.ok) {
+ throw new Error("Network response was not ok " + response.statusText);
+ }
+ const data = await response.text(); // Get the content as text
+ return data;
+ } catch (error) {
+ console.error("There has been a problem with your fetch operation:", error);
+ }
+}
+
+function addMaxLengthToExternalInputs(
+ externalInputs: ExternalInputInput[],
+ externalInputDefinitions?: ExternalInput[]
+) {
+ const externalInputsWithMaxLength: (ExternalInputInput & { maxLength: number })[] = [];
+ if (externalInputDefinitions) {
+ for (const externalInputDefinition of externalInputDefinitions) {
+ const externalInput = externalInputs.find((ei) => ei.name === externalInputDefinition.name);
+ if (!externalInput) {
+ throw new Error(`You must provide the external input for ${externalInputDefinition.name}`);
+ }
+ externalInputsWithMaxLength.push({
+ ...externalInput,
+ maxLength: externalInputDefinition.maxLength,
+ });
+ }
+ }
+ return externalInputsWithMaxLength;
+}
+
+function parseNoirPublicOutputs(
+ publicOutputs: string[],
+ decomposedRegexes: DecomposedRegex[],
+ externalInputDefinition?: ExternalInput[],
+ externalInputs?: ExternalInputInput[]
+): { publicData: PublicProofData; externalInputsProof?: ExternalInputProof } {
+ // 0: pubkey hash
+ // 1: header_hash[0]
+ // 2: header_hash[1]
+ // 3: prover_address
+ let publicOutputIterator = 4;
+
+ const publicStruct: { [key: string]: string[] } = {};
+ const result: { publicData: PublicProofData; externalInputsProof?: ExternalInputProof } = {
+ publicData: publicStruct,
+ };
+
+ if (externalInputs) {
+ const externalInputsWithMaxLength = addMaxLengthToExternalInputs(
+ externalInputs,
+ externalInputDefinition
+ );
+
+ result.externalInputsProof = {};
+ externalInputsWithMaxLength.forEach((externalInput) => {
+ const signalLength =
+ Math.floor(externalInput.maxLength / 31) + (externalInput.maxLength % 31 !== 0 ? 1 : 0);
+ publicOutputIterator += signalLength;
+ result.externalInputsProof![externalInput.name] = externalInput.value;
+ });
+ }
+
+ decomposedRegexes.forEach((decomposedRegex) => {
+ const partOutputs: string[] = [];
+
+ const { maxLength } = decomposedRegex;
+ decomposedRegex.parts.forEach((part) => {
+ if (decomposedRegex.isHashed) {
+ partOutputs.push(publicOutputs[publicOutputIterator]);
+ publicOutputIterator++;
+ } else if (part.isPublic) {
+ let partStr = "";
+ for (let i = publicOutputIterator; i < publicOutputIterator + maxLength; i++) {
+ const char = toUtf8(publicOutputs[i]);
+ partStr += char;
+ }
+ partOutputs.push(partStr);
+ publicOutputIterator += maxLength;
+ // The next element is the length of the part
+ const partLength = parseInt(publicOutputs[publicOutputIterator], 16);
+ if (partStr.length !== partLength) {
+ throw new Error("Length of part didn't match the given length output");
+ }
+ publicOutputIterator++;
+ }
+ });
+
+ // Collect all part outputs for this decomposedRegex
+ publicStruct[decomposedRegex.name] = partOutputs;
+ });
+
+ return result;
+}
+
+function toUtf8(hex: string): string {
+ // Remove '0x' prefix and leading zeros
+ const cleanHex = hex.slice(2).replace(/^0+/, "");
+
+ // Convert the hex to a Uint8Array
+ const bytes = new Uint8Array(cleanHex.length / 2);
+ for (let i = 0; i < cleanHex.length; i += 2) {
+ bytes[i / 2] = parseInt(cleanHex.substring(i, i + 2), 16);
+ }
+
+ // Use TextDecoder to convert to UTF-8
+ return new TextDecoder().decode(bytes);
+}
diff --git a/browser_test/src/style.css b/browser_test/src/style.css
new file mode 100644
index 0000000..8df73e3
--- /dev/null
+++ b/browser_test/src/style.css
@@ -0,0 +1,96 @@
+:root {
+ font-family: system-ui, Avenir, Helvetica, Arial, sans-serif;
+ line-height: 1.5;
+ font-weight: 400;
+
+ color-scheme: light dark;
+ color: rgba(255, 255, 255, 0.87);
+ background-color: #242424;
+
+ font-synthesis: none;
+ text-rendering: optimizeLegibility;
+ -webkit-font-smoothing: antialiased;
+ -moz-osx-font-smoothing: grayscale;
+}
+
+a {
+ font-weight: 500;
+ color: #646cff;
+ text-decoration: inherit;
+}
+a:hover {
+ color: #535bf2;
+}
+
+body {
+ margin: 0;
+ display: flex;
+ place-items: center;
+ min-width: 320px;
+ min-height: 100vh;
+}
+
+h1 {
+ font-size: 3.2em;
+ line-height: 1.1;
+}
+
+#app {
+ max-width: 1280px;
+ margin: 0 auto;
+ padding: 2rem;
+ text-align: center;
+}
+
+.logo {
+ height: 6em;
+ padding: 1.5em;
+ will-change: filter;
+ transition: filter 300ms;
+}
+.logo:hover {
+ filter: drop-shadow(0 0 2em #646cffaa);
+}
+.logo.vanilla:hover {
+ filter: drop-shadow(0 0 2em #f7df1eaa);
+}
+
+.card {
+ padding: 2em;
+}
+
+.read-the-docs {
+ color: #888;
+}
+
+button {
+ border-radius: 8px;
+ border: 1px solid transparent;
+ padding: 0.6em 1.2em;
+ font-size: 1em;
+ font-weight: 500;
+ font-family: inherit;
+ background-color: #1a1a1a;
+ cursor: pointer;
+ transition: border-color 0.25s;
+}
+button:hover {
+ border-color: #646cff;
+}
+button:focus,
+button:focus-visible {
+ outline: 4px auto -webkit-focus-ring-color;
+}
+
+@media (prefers-color-scheme: light) {
+ :root {
+ color: #213547;
+ background-color: #ffffff;
+ }
+ a:hover {
+ color: #747bff;
+ }
+ button {
+ background-color: #f9f9f9;
+ }
+}
diff --git a/browser_test/tsconfig.json b/browser_test/tsconfig.json
new file mode 100644
index 0000000..36d9279
--- /dev/null
+++ b/browser_test/tsconfig.json
@@ -0,0 +1,23 @@
+{
+ "compilerOptions": {
+ "target": "ES2020",
+ "useDefineForClassFields": true,
+ "module": "ESNext",
+ "lib": ["ES2020", "DOM", "DOM.Iterable"],
+ "skipLibCheck": true,
+
+ /* Bundler mode */
+ "moduleResolution": "bundler",
+ "allowImportingTsExtensions": true,
+ "resolveJsonModule": true,
+ "isolatedModules": true,
+ "noEmit": true,
+
+ /* Linting */
+ "strict": true,
+ "noUnusedLocals": true,
+ "noUnusedParameters": true,
+ "noFallthroughCasesInSwitch": true
+ },
+ "include": ["src"]
+}
\ No newline at end of file
diff --git a/browser_test/vite.config.js b/browser_test/vite.config.js
new file mode 100644
index 0000000..7d5d3de
--- /dev/null
+++ b/browser_test/vite.config.js
@@ -0,0 +1,80 @@
+import { defineConfig } from "vite";
+import path from "path";
+import commonjs from "vite-plugin-commonjs";
+import { NodeGlobalsPolyfillPlugin } from "@esbuild-plugins/node-globals-polyfill";
+import rollupNodePolyfills from "rollup-plugin-node-polyfills";
+
+export default defineConfig({
+ worker: {
+ format: "es",
+ },
+ server: {
+ port: 3000,
+ },
+ preview: {
+ port: 3000,
+ },
+ publicDir: "public",
+ plugins: [
+ commonjs(), // Handles CommonJS modules
+ {
+ ...rollupNodePolyfills(), // Polyfills Node.js modules
+ apply: "build",
+ },
+ ],
+ resolve: {
+ alias: {
+ "node:buffer": "buffer",
+ "node:stream": "stream-browserify",
+ buffer: "buffer",
+ process: path.resolve("node_modules/rollup-plugin-node-polyfills/polyfills/process-es6"),
+ util: path.resolve("node_modules/rollup-plugin-node-polyfills/polyfills/util"),
+ sys: "util",
+ events: path.resolve("node_modules/rollup-plugin-node-polyfills/polyfills/events"),
+ stream: "stream-browserify",
+ path: path.resolve("node_modules/rollup-plugin-node-polyfills/polyfills/path"),
+ querystring: path.resolve("node_modules/rollup-plugin-node-polyfills/polyfills/qs"),
+ url: path.resolve("node_modules/rollup-plugin-node-polyfills/polyfills/url"),
+ crypto: "crypto-browserify",
+ http: path.resolve("node_modules/rollup-plugin-node-polyfills/polyfills/http"),
+ https: path.resolve("node_modules/rollup-plugin-node-polyfills/polyfills/http"),
+ os: path.resolve("node_modules/rollup-plugin-node-polyfills/polyfills/os"),
+ assert: path.resolve("node_modules/rollup-plugin-node-polyfills/polyfills/assert"),
+ constants: path.resolve("node_modules/rollup-plugin-node-polyfills/polyfills/constants"),
+ _stream_duplex: path.resolve(
+ "node_modules/rollup-plugin-node-polyfills/polyfills/readable-stream/duplex"
+ ),
+ _stream_passthrough: path.resolve(
+ "node_modules/rollup-plugin-node-polyfills/polyfills/readable-stream/passthrough"
+ ),
+ _stream_readable: path.resolve(
+ "node_modules/rollup-plugin-node-polyfills/polyfills/readable-stream/readable"
+ ),
+ _stream_writable: path.resolve(
+ "node_modules/rollup-plugin-node-polyfills/polyfills/readable-stream/writable"
+ ),
+ _stream_transform: path.resolve(
+ "node_modules/rollup-plugin-node-polyfills/polyfills/readable-stream/transform"
+ ),
+ timers: path.resolve("node_modules/rollup-plugin-node-polyfills/polyfills/timers"),
+ console: path.resolve("node_modules/rollup-plugin-node-polyfills/polyfills/console"),
+ vm: path.resolve("node_modules/rollup-plugin-node-polyfills/polyfills/vm"),
+ zlib: path.resolve("node_modules/rollup-plugin-node-polyfills/polyfills/zlib"),
+ tty: path.resolve("node_modules/rollup-plugin-node-polyfills/polyfills/tty"),
+ domain: path.resolve("node_modules/rollup-plugin-node-polyfills/polyfills/domain"),
+ },
+ },
+ define: {
+ global: "globalThis", // Polyfill `global` for browser environments
+ },
+ optimizeDeps: {
+ esbuildOptions: {
+ plugins: [
+ NodeGlobalsPolyfillPlugin({
+ process: true,
+ buffer: true,
+ }),
+ ],
+ },
+ },
+});
diff --git a/package.json b/package.json
index cdcf168..d5d3219 100644
--- a/package.json
+++ b/package.json
@@ -10,7 +10,7 @@
"wasm:postbuild": "node build.js",
"build": "npm run wasm:build && npm run wasm:postbuild"
},
- "version": "0.4.65",
+ "version": "0.4.66-2",
"devDependencies": {
"@types/bun": "latest",
"prettier": "^3.3.3"
diff --git a/src/circuit.rs b/src/circuit/circom.rs
similarity index 68%
rename from src/circuit.rs
rename to src/circuit/circom.rs
index f275550..ea3c84b 100644
--- a/src/circuit.rs
+++ b/src/circuit/circom.rs
@@ -1,18 +1,20 @@
-use anyhow::{anyhow, Result};
-use num_bigint::BigInt;
-use regex::Regex;
+use anyhow::Result;
use serde::{Deserialize, Serialize};
use serde_json::{json, Value};
-use std::{cmp, collections::VecDeque};
+use std::collections::VecDeque;
use zk_regex_apis::extract_substrs::{
extract_substr_idxes, DecomposedRegexConfig, RegexPartConfig,
};
use crate::{
- field_to_hex, find_index_in_body, generate_partial_sha, hex_to_u256,
- remove_quoted_printable_soft_breaks, sha256_pad, string_to_circom_bigint_bytes,
- to_circom_bigint_bytes, vec_u8_to_bigint, AccountCode, PaddedEmailAddr, ParsedEmail,
- MAX_BODY_PADDED_BYTES, MAX_HEADER_PADDED_BYTES,
+ field_to_hex, find_index_in_body, hex_to_u256, remove_quoted_printable_soft_breaks,
+ string_to_circom_bigint_bytes, vec_u8_to_bigint, AccountCode, PaddedEmailAddr, ParsedEmail,
+};
+
+use super::{
+ generate_circuit_inputs, CircuitInputParams,
+ CircuitInputWithDecomposedRegexesAndExternalInputsParams, CircuitOptions, CircuitParams,
+ ExternalInput,
};
#[derive(Serialize, Deserialize)]
@@ -52,53 +54,6 @@ struct ClaimCircuitInput {
account_code: String, // The account code as a string
}
-struct CircuitInput {
- pub header_padded: Vec, // The padded version of the email header
- pub pubkey: Vec, // The public key in string format
- pub signature: Vec, // The signature in string format
- pub header_len_padded_bytes: usize, // The length of the padded header in bytes
- pub precomputed_sha: Option>, // The precomputed SHA-256 hash of the body, if present
- pub body_padded: Option>, // The padded version of the email body, if present
- pub body_len_padded_bytes: Option, // The length of the padded body in bytes, if present
- pub body_hash_idx: Option, // The index in header where the body hash is stored
-}
-
-#[derive(Debug, Clone)]
-pub struct CircuitInputParams {
- body: Vec, // The email body in bytes
- header: Vec, // The email header in bytes
- body_hash_idx: usize, // The index of the body hash within the circuit
- rsa_signature: BigInt, // The RSA signature as a BigInt
- rsa_public_key: BigInt, // The RSA public key as a BigInt
- sha_precompute_selector: Option, // Regex Selector for SHA-256 precomputation
- max_header_length: usize, // The maximum length of the email header
- max_body_length: usize, // The maximum length of the email body
- ignore_body_hash_check: bool, // Flag to ignore the body hash check
-}
-
-pub struct CircuitParams {
- pub body: Vec, // The email body in bytes
- pub header: Vec, // The email header in bytes
- pub body_hash_idx: usize, // The index of the body hash in the header
- pub rsa_signature: BigInt, // The RSA signature as a BigInt
- pub rsa_public_key: BigInt, // The RSA public key as a BigInt
-}
-
-pub struct CircuitOptions {
- pub sha_precompute_selector: Option, // Selector for SHA-256 precomputation
- pub max_header_length: Option, // The maximum length of the email header
- pub max_body_length: Option, // The maximum length of the email body
- pub ignore_body_hash_check: Option, // Flag to ignore the body hash check
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
-#[serde(rename_all = "camelCase")]
-pub struct ExternalInput {
- pub name: String, // The name of the external input
- pub value: Option, // The optional value of the external input
- pub max_length: usize, // The maximum length of the input value
-}
-
#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all = "camelCase")]
pub struct DecomposedRegex {
@@ -108,225 +63,6 @@ pub struct DecomposedRegex {
pub location: String, // The location where the regex is applied (e.g., header or body)
}
-#[derive(Serialize, Deserialize, Debug, Clone)]
-#[serde(rename_all = "camelCase")]
-pub struct CircuitInputWithDecomposedRegexesAndExternalInputsParams {
- pub prover_eth_address: Option, // The Ethereum address of the prover
- pub max_header_length: usize, // The maximum length of the email header
- pub max_body_length: usize, // The maximum length of the email body
- pub ignore_body_hash_check: bool, // Flag to ignore the body hash check
- pub remove_soft_lines_breaks: bool, // Flag to remove soft line breaks from the body
- pub sha_precompute_selector: Option, // Optional regex selector for SHA-256 precomputation
-}
-
-impl CircuitInputParams {
- /// Creates a new `CircuitInputParams` instance with provided parameters and options.
- ///
- /// # Arguments
- ///
- /// * `params` - A `CircuitParams` struct containing:
- /// * `body`: A vector of bytes representing the email body.
- /// * `header`: A vector of bytes representing the email header.
- /// * `body_hash_idx`: The index of the body hash within the circuit.
- /// * `rsa_signature`: The RSA signature as a BigInt.
- /// * `rsa_public_key`: The RSA public key as a BigInt.
- ///
- /// * `options` - A `CircuitOptions` struct containing optional parameters:
- /// * `sha_precompute_selector`: Selector for SHA-256 precomputation.
- /// * `max_header_length`: Maximum length of the email header, with a default value if not provided.
- /// * `max_body_length`: Maximum length of the email body, with a default value if not provided.
- /// * `ignore_body_hash_check`: Flag to ignore the body hash check, defaults to false if not provided.
- ///
- /// # Returns
- ///
- /// A `CircuitInputParams` instance with the specified parameters and options applied.
- pub fn new(params: CircuitParams, options: CircuitOptions) -> Self {
- CircuitInputParams {
- body: params.body,
- header: params.header,
- body_hash_idx: params.body_hash_idx,
- rsa_signature: params.rsa_signature,
- rsa_public_key: params.rsa_public_key,
- sha_precompute_selector: options.sha_precompute_selector,
- // Use the provided max_header_length or default to MAX_HEADER_PADDED_BYTES
- max_header_length: options.max_header_length.unwrap_or(MAX_HEADER_PADDED_BYTES),
- // Use the provided max_body_length or default to MAX_BODY_PADDED_BYTES
- max_body_length: options.max_body_length.unwrap_or(MAX_BODY_PADDED_BYTES),
- // Use the provided ignore_body_hash_check or default to false
- ignore_body_hash_check: options.ignore_body_hash_check.unwrap_or(false),
- }
- }
-}
-
-/// Finds a selector string in cleaned content and maps it back to its original position.
-///
-/// # Arguments
-/// * `clean_content` - The cleaned content as a slice of bytes (no QP soft line breaks).
-/// * `selector` - The string to find in the cleaned content.
-/// * `position_map` - A slice mapping cleaned indices to original indices.
-/// For each i, `position_map[i]` is the index in `original_body` where that cleaned byte originated.
-/// If `position_map[i]` is `usize::MAX`, that cleaned position has no corresponding original position.
-///
-/// # Returns
-/// A tuple containing `(selector, original_index)`.
-///
-/// # Errors
-/// Returns an error if the selector is not found in the cleaned content or if the position mapping fails.
-fn find_selector_in_clean_content(
- clean_content: &[u8],
- selector: &str,
- position_map: &[usize],
-) -> Result<(String, usize, usize)> {
- let clean_string = String::from_utf8_lossy(clean_content);
- let re = Regex::new(selector).unwrap();
- if let Some(m) = re.find(&clean_string) {
- let selector_start_index = m.start();
- let selector_end_index = m.end();
- // Map this cleaned index back to original
- if selector_start_index < position_map.len() && selector_end_index < position_map.len() {
- let original_start_index = position_map[selector_start_index];
- let original_end_index = position_map[selector_end_index];
- if original_start_index == usize::MAX || original_end_index == usize::MAX {
- return Err(anyhow!("Failed to map selector position to original body"));
- }
- Ok((
- selector.to_string(),
- original_start_index,
- original_end_index,
- ))
- } else {
- Err(anyhow!("Selector index out of range in position map"))
- }
- } else {
- Err(anyhow!(
- "SHA precompute selector \"{}\" not found in cleaned body",
- selector
- ))
- }
-}
-
-/// Gets the adjusted selector string that accounts for potential soft line breaks in QP encoding.
-/// If the selector exists in the original body, returns it as-is. Otherwise, finds it in cleaned
-/// content and maps it back to the original format, including any soft line breaks.
-///
-/// # Arguments
-/// * `original_body` - The original body as a slice of bytes, possibly containing QP soft line breaks.
-/// * `selector` - The string to find in the content.
-/// * `clean_content` - The cleaned content with soft line breaks removed.
-/// * `position_map` - The index mapping from cleaned content to original content.
-///
-/// # Returns
-/// The adjusted selector string that matches the original body format.
-///
-/// # Errors
-/// Returns an error if the selector cannot be found in either the original or cleaned content.
-fn get_adjusted_selector(
- original_body: &[u8],
- selector: &str,
- clean_content: &[u8],
- position_map: &[usize],
-) -> Result {
- let original_str = String::from_utf8_lossy(original_body);
-
- // First, try finding the selector in the original body as-is
- if original_str.contains(selector) {
- return Ok(selector.to_string());
- }
-
- // If not found, we must find it in the cleaned content and map back to original
- let (_, original_start_index, original_end_index) =
- find_selector_in_clean_content(clean_content, selector, position_map)?;
-
- // Retrieve the substring from the original body that corresponds to the found selector
- let adjusted_slice = &original_body[original_start_index..original_end_index];
-
- // Convert back to a string. If invalid UTF-8, use lossy conversion.
- let adjusted_str = regex::escape(&String::from_utf8_lossy(adjusted_slice));
- Ok(adjusted_str.to_string())
-}
-
-/// Generates the inputs for the circuit from the given parameters.
-///
-/// This function takes `CircuitInputParams` which includes the email body and header,
-/// RSA signature and public key, and other optional parameters. It processes these
-/// inputs to create a `CircuitInput` struct which is used in the zero-knowledge proof
-/// circuit.
-///
-/// # Arguments
-///
-/// * `params` - A `CircuitInputParams` struct containing the necessary parameters.
-///
-/// # Returns
-///
-/// A `Result` which is either a `CircuitInput` struct on success or an error on failure.
-///
-/// # Panics
-///
-/// This function panics if the partial SHA-256 generation fails.
-fn generate_circuit_inputs(params: CircuitInputParams) -> Result {
- // Pad the header to the specified maximum length or the default
- let (header_padded, header_padded_len) =
- sha256_pad(params.header.clone(), params.max_header_length);
-
- // Initialize the circuit input with the padded header and RSA information
- let mut circuit_input = CircuitInput {
- header_padded,
- pubkey: to_circom_bigint_bytes(params.rsa_public_key),
- signature: to_circom_bigint_bytes(params.rsa_signature),
- header_len_padded_bytes: header_padded_len,
- precomputed_sha: None,
- body_padded: None,
- body_len_padded_bytes: None,
- body_hash_idx: None,
- };
-
- // If body hash check is not ignored, include the precomputed SHA and body information
- if !params.ignore_body_hash_check {
- // Calculate the length needed for SHA-256 padding of the body
- let body_sha_length = ((params.body.len() + 63 + 65) / 64) * 64;
- // Pad the body to the maximum length or the calculated SHA-256 padding length
- let (body_padded, body_padded_len) = sha256_pad(
- params.body.clone(),
- cmp::max(params.max_body_length, body_sha_length),
- );
-
- let mut adjusted_selector = params.sha_precompute_selector;
-
- if adjusted_selector.is_some() {
- let (cleaned_body, position_map) =
- remove_quoted_printable_soft_breaks(body_padded.clone());
- adjusted_selector = Some(get_adjusted_selector(
- ¶ms.body,
- &adjusted_selector.as_ref().unwrap(),
- &cleaned_body,
- &position_map,
- )?);
- }
-
- // Ensure that the error type returned by `generate_partial_sha` is sized
- // by converting it into an `anyhow::Error` if it's not already.
- let result = generate_partial_sha(
- body_padded,
- body_padded_len,
- adjusted_selector,
- params.max_body_length,
- );
-
- // Use match to handle the result and convert any error into an anyhow::Error
- let (precomputed_sha, body_remaining, body_remaining_length) = match result {
- Ok((sha, remaining, len)) => (sha, remaining, len),
- Err(e) => panic!("Failed to generate partial SHA: {:?}", e),
- };
-
- circuit_input.precomputed_sha = Some(precomputed_sha);
- circuit_input.body_hash_idx = Some(params.body_hash_idx);
- circuit_input.body_padded = Some(body_remaining);
- circuit_input.body_len_padded_bytes = Some(body_remaining_length);
- }
-
- Ok(circuit_input)
-}
-
/// Asynchronously generates the circuit input for an email.
///
/// This function processes an email and its associated account code along with optional
@@ -451,7 +187,7 @@ pub async fn generate_email_circuit_input(
code_idx,
padded_body: email_circuit_inputs.body_padded,
body_hash_idx: email_circuit_inputs.body_hash_idx,
- padded_body_len: email_circuit_inputs.body_len_padded_bytes,
+ padded_body_len: email_circuit_inputs.body_padded_len,
precomputed_sha: email_circuit_inputs.precomputed_sha,
command_idx,
padded_cleaned_body: padded_cleaned_body.map(|(cleaned_body, _)| cleaned_body),
@@ -562,7 +298,7 @@ pub async fn generate_circuit_inputs_with_decomposed_regexes_and_external_inputs
circuit_inputs["bodyHashIndex"] = email_circuit_inputs.body_hash_idx.into();
circuit_inputs["precomputedSHA"] = email_circuit_inputs.precomputed_sha.into();
circuit_inputs["emailBody"] = email_circuit_inputs.body_padded.clone().into();
- circuit_inputs["emailBodyLength"] = email_circuit_inputs.body_len_padded_bytes.into();
+ circuit_inputs["emailBodyLength"] = email_circuit_inputs.body_padded_len.into();
}
// Clean the body by removing quoted-printable soft breaks if necessary
@@ -572,7 +308,7 @@ pub async fn generate_circuit_inputs_with_decomposed_regexes_and_external_inputs
.map(remove_quoted_printable_soft_breaks);
// Add the cleaned body to the circuit inputs if soft line breaks are to be removed
- if params.remove_soft_lines_breaks {
+ if params.remove_soft_line_breaks {
if let Some((cleaned_body_vec, _)) = cleaned_body.clone() {
circuit_inputs["decodedEmailBodyIn"] = cleaned_body_vec.into();
}
@@ -590,7 +326,7 @@ pub async fn generate_circuit_inputs_with_decomposed_regexes_and_external_inputs
// Determine the input string based on the regex location
let input = if decomposed_regex.location == "header" {
String::from_utf8_lossy(&email_circuit_inputs.header_padded.clone()).into_owned()
- } else if decomposed_regex.location == "body" && params.remove_soft_lines_breaks {
+ } else if decomposed_regex.location == "body" && params.remove_soft_line_breaks {
cleaned_body
.as_ref()
.map(|(v, _)| String::from_utf8_lossy(v).into_owned())
@@ -707,7 +443,7 @@ mod tests {
max_body_length: 2816,
max_header_length: 1024,
ignore_body_hash_check: false,
- remove_soft_lines_breaks: true,
+ remove_soft_line_breaks: true,
sha_precompute_selector: None,
prover_eth_address: Some("0x9401296121FC9B78F84fc856B1F8dC88f4415B2e".to_string()),
},
@@ -773,7 +509,7 @@ mod tests {
max_body_length: 2816,
max_header_length: 1024,
ignore_body_hash_check: false,
- remove_soft_lines_breaks: true,
+ remove_soft_line_breaks: true,
sha_precompute_selector: None,
prover_eth_address: Some("0x9401296121FC9B78F84fc856B1F8dC88f4415B2e".to_string()),
},
@@ -846,7 +582,7 @@ mod tests {
max_body_length: 3136,
max_header_length: 1024,
ignore_body_hash_check: false,
- remove_soft_lines_breaks: true,
+ remove_soft_line_breaks: true,
sha_precompute_selector: Some(">Not my account<".to_string()),
prover_eth_address: Some("0x9401296121FC9B78F84fc856B1F8dC88f4415B2e".to_string()),
},
@@ -1000,7 +736,7 @@ mod tests {
max_body_length: 0,
max_header_length: 1024,
ignore_body_hash_check: true,
- remove_soft_lines_breaks: true,
+ remove_soft_line_breaks: true,
sha_precompute_selector: None,
prover_eth_address: Some("0x9401296121FC9B78F84fc856B1F8dC88f4415B2e".to_string()),
},
diff --git a/src/circuit/mod.rs b/src/circuit/mod.rs
new file mode 100644
index 0000000..8b4413f
--- /dev/null
+++ b/src/circuit/mod.rs
@@ -0,0 +1,196 @@
+mod circom;
+mod noir;
+mod utils;
+
+pub use circom::*;
+pub use noir::*;
+pub use utils::*;
+
+use anyhow::Result;
+use num_bigint::BigInt;
+use serde::{Deserialize, Serialize};
+use std::cmp;
+
+use crate::{
+ generate_partial_sha, remove_quoted_printable_soft_breaks, sha256_pad, to_circom_bigint_bytes,
+ MAX_BODY_PADDED_BYTES, MAX_HEADER_PADDED_BYTES,
+};
+
+#[derive(Debug, Clone)]
+pub struct CircuitInputParams {
+ body: Vec, // The email body in bytes
+ header: Vec, // The email header in bytes
+ body_hash_idx: usize, // The index of the body hash within the circuit
+ rsa_signature: BigInt, // The RSA signature as a BigInt
+ rsa_public_key: BigInt, // The RSA public key as a BigInt
+ sha_precompute_selector: Option, // Regex Selector for SHA-256 precomputation
+ max_header_length: usize, // The maximum length of the email header
+ max_body_length: usize, // The maximum length of the email body
+ ignore_body_hash_check: bool, // Flag to ignore the body hash check
+}
+
+struct CircuitInput {
+ pub header_padded: Vec, // The padded version of the email header
+ pub pubkey: Vec, // The public key in string format
+ pub signature: Vec, // The signature in string format
+ pub header_len_padded_bytes: usize, // The length of the padded header in bytes
+ pub precomputed_sha: Option>, // The precomputed SHA-256 hash of the body, if present
+ pub body_padded: Option>, // The padded version of the email body, if present
+ pub body_padded_len: Option, // The length of the padded body in bytes, if present
+ pub body_hash_idx: Option, // The index in header where the body hash is stored
+}
+
+pub struct CircuitParams {
+ pub body: Vec, // The email body in bytes
+ pub header: Vec, // The email header in bytes
+ pub body_hash_idx: usize, // The index of the body hash in the header
+ pub rsa_signature: BigInt, // The RSA signature as a BigInt
+ pub rsa_public_key: BigInt, // The RSA public key as a BigInt
+}
+
+pub struct CircuitOptions {
+ pub sha_precompute_selector: Option, // Selector for SHA-256 precomputation
+ pub max_header_length: Option, // The maximum length of the email header
+ pub max_body_length: Option, // The maximum length of the email body
+ pub ignore_body_hash_check: Option, // Flag to ignore the body hash check
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct ExternalInput {
+ pub name: String, // The name of the external input
+ pub value: Option, // The optional value of the external input
+ pub max_length: usize, // The maximum length of the input value
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct CircuitInputWithDecomposedRegexesAndExternalInputsParams {
+ pub prover_eth_address: Option, // The Ethereum address of the prover
+ pub max_header_length: usize, // The maximum length of the email header
+ pub max_body_length: usize, // The maximum length of the email body
+ pub ignore_body_hash_check: bool, // Flag to ignore the body hash check
+ pub remove_soft_line_breaks: bool, // Flag to remove soft line breaks from the body
+ pub sha_precompute_selector: Option, // Optional regex selector for SHA-256 precomputation
+}
+
+impl CircuitInputParams {
+ /// Creates a new `CircuitInputParams` instance with provided parameters and options.
+ ///
+ /// # Arguments
+ ///
+ /// * `params` - A `CircuitParams` struct containing:
+ /// * `body`: A vector of bytes representing the email body.
+ /// * `header`: A vector of bytes representing the email header.
+ /// * `body_hash_idx`: The index of the body hash within the circuit.
+ /// * `rsa_signature`: The RSA signature as a BigInt.
+ /// * `rsa_public_key`: The RSA public key as a BigInt.
+ ///
+ /// * `options` - A `CircuitOptions` struct containing optional parameters:
+ /// * `sha_precompute_selector`: Selector for SHA-256 precomputation.
+ /// * `max_header_length`: Maximum length of the email header, with a default value if not provided.
+ /// * `max_body_length`: Maximum length of the email body, with a default value if not provided.
+ /// * `ignore_body_hash_check`: Flag to ignore the body hash check, defaults to false if not provided.
+ ///
+ /// # Returns
+ ///
+ /// A `CircuitInputParams` instance with the specified parameters and options applied.
+ pub fn new(params: CircuitParams, options: CircuitOptions) -> Self {
+ CircuitInputParams {
+ body: params.body,
+ header: params.header,
+ body_hash_idx: params.body_hash_idx,
+ rsa_signature: params.rsa_signature,
+ rsa_public_key: params.rsa_public_key,
+ sha_precompute_selector: options.sha_precompute_selector,
+ // Use the provided max_header_length or default to MAX_HEADER_PADDED_BYTES
+ max_header_length: options.max_header_length.unwrap_or(MAX_HEADER_PADDED_BYTES),
+ // Use the provided max_body_length or default to MAX_BODY_PADDED_BYTES
+ max_body_length: options.max_body_length.unwrap_or(MAX_BODY_PADDED_BYTES),
+ // Use the provided ignore_body_hash_check or default to false
+ ignore_body_hash_check: options.ignore_body_hash_check.unwrap_or(false),
+ }
+ }
+}
+
+/// Generates the inputs for the circuit from the given parameters.
+///
+/// This function takes `CircuitInputParams` which includes the email body and header,
+/// RSA signature and public key, and other optional parameters. It processes these
+/// inputs to create a `CircuitInput` struct which is used in the zero-knowledge proof
+/// circuit.
+///
+/// # Arguments
+///
+/// * `params` - A `CircuitInputParams` struct containing the necessary parameters.
+///
+/// # Returns
+///
+/// A `Result` which is either a `CircuitInput` struct on success or an error on failure.
+///
+/// # Panics
+///
+/// This function panics if the partial SHA-256 generation fails.
+fn generate_circuit_inputs(params: CircuitInputParams) -> Result {
+ // Pad the header to the specified maximum length or the default
+ let (header_padded, header_padded_len) =
+ sha256_pad(params.header.clone(), params.max_header_length);
+
+ // Initialize the circuit input with the padded header and RSA information
+ let mut circuit_input = CircuitInput {
+ header_padded,
+ pubkey: to_circom_bigint_bytes(params.rsa_public_key),
+ signature: to_circom_bigint_bytes(params.rsa_signature),
+ header_len_padded_bytes: header_padded_len,
+ precomputed_sha: None,
+ body_padded: None,
+ body_padded_len: None,
+ body_hash_idx: None,
+ };
+
+ // If body hash check is not ignored, include the precomputed SHA and body information
+ if !params.ignore_body_hash_check {
+ // Calculate the length needed for SHA-256 padding of the body
+ let body_sha_length = ((params.body.len() + 63 + 65) / 64) * 64;
+ // Pad the body to accommodate both SHA-256 requirements and maximum length constraints
+ let (body_padded, body_sha_block_len) = sha256_pad(
+ params.body.clone(),
+ cmp::max(params.max_body_length, body_sha_length),
+ );
+
+ let mut adjusted_selector = params.sha_precompute_selector;
+
+ if adjusted_selector.is_some() {
+ let (cleaned_body, position_map) =
+ remove_quoted_printable_soft_breaks(params.body.clone());
+ adjusted_selector = Some(get_adjusted_selector(
+ ¶ms.body,
+ &adjusted_selector.as_ref().unwrap(),
+ &cleaned_body,
+ &position_map,
+ )?);
+ }
+
+ // Ensure that the error type returned by `generate_partial_sha` is sized
+ // by converting it into an `anyhow::Error` if it's not already.
+ let result = generate_partial_sha(
+ body_padded,
+ body_sha_block_len,
+ adjusted_selector,
+ params.max_body_length,
+ );
+
+ // Use match to handle the result and convert any error into an anyhow::Error
+ let (precomputed_sha, body_remaining_padded, body_remaining_length) = match result {
+ Ok((sha, remaining, len)) => (sha, remaining, len),
+ Err(e) => panic!("Failed to generate partial SHA: {:?}", e),
+ };
+
+ circuit_input.precomputed_sha = Some(precomputed_sha);
+ circuit_input.body_hash_idx = Some(params.body_hash_idx);
+ circuit_input.body_padded = Some(body_remaining_padded);
+ circuit_input.body_padded_len = Some(body_remaining_length);
+ }
+
+ Ok(circuit_input)
+}
diff --git a/src/circuit/noir/mod.rs b/src/circuit/noir/mod.rs
new file mode 100644
index 0000000..522dd07
--- /dev/null
+++ b/src/circuit/noir/mod.rs
@@ -0,0 +1,398 @@
+mod structs;
+mod utils;
+
+pub use structs::*;
+pub use utils::*;
+
+use anyhow::Result;
+use num_bigint::{BigUint, ToBigInt};
+use serde_json::Value;
+
+use zk_regex_compiler::{gen_circuit_inputs, NFAGraph, ProverInputs};
+
+use crate::{
+ remove_quoted_printable_soft_breaks, string_to_circom_bigint_bytes, vec_u8_to_bigint,
+ ParsedEmail,
+};
+
+use super::{
+ compute_signal_length, generate_circuit_inputs, CircuitInputParams,
+ CircuitInputWithDecomposedRegexesAndExternalInputsParams, CircuitOptions, CircuitParams,
+ ExternalInput,
+};
+
+pub const MODULUS_BITS: usize = 2048;
+
+pub async fn generate_noir_circuit_input(
+ email: &str,
+ params: NoirInputGenerationArgs,
+) -> Result {
+ // Parse the raw email to extract canonicalized body and header, and other components
+ let parsed_email =
+ ParsedEmail::new_from_raw_email(email, params.ignore_body_hash_check.unwrap_or(true))
+ .await?;
+
+ // Clone the fields that are used by value before the move occurs
+ let public_key = BigUint::from_bytes_be(&parsed_email.public_key)
+ .to_bigint()
+ .unwrap();
+ let signature = BigUint::from_bytes_be(&parsed_email.signature)
+ .to_bigint()
+ .unwrap();
+
+ // Create a CircuitParams struct from the parsed email
+ let circuit_params = CircuitParams {
+ body: parsed_email.canonicalized_body.as_bytes().to_vec(),
+ header: parsed_email.canonicalized_header.as_bytes().to_vec(),
+ body_hash_idx: parsed_email.get_body_hash_idxes()?.0,
+ rsa_signature: vec_u8_to_bigint(parsed_email.signature),
+ rsa_public_key: vec_u8_to_bigint(parsed_email.public_key),
+ };
+
+ // Create a CircuitOptions struct from the optional parameters
+ let circuit_options = CircuitOptions {
+ sha_precompute_selector: params.sha_precompute_selector.clone(),
+ max_header_length: params.max_headers_length,
+ max_body_length: params.max_body_length,
+ ignore_body_hash_check: params.ignore_body_hash_check,
+ };
+
+ // Create circuit input parameters from the CircuitParams and CircuitOptions structs
+ let circuit_input_params = CircuitInputParams::new(circuit_params, circuit_options);
+
+ // Generate the circuit inputs from the parameters
+ let email_circuit_inputs = generate_circuit_inputs(circuit_input_params.clone())?;
+
+ // Create the Pubkey struct for the NoirCircuitInput
+ let pubkey = Pubkey {
+ modulus: bn_to_limb_str_array(&public_key, Some(MODULUS_BITS)),
+ redc: bn_to_redc_limb_str_array(&public_key, Some(MODULUS_BITS)),
+ };
+
+ // Get the DKIM header sequence
+ let dkim_header_sequence = get_header_sequence(
+ &parsed_email.canonicalized_header.as_bytes(),
+ "dkim-signature",
+ )?;
+
+ // Create the BoundedVec for the header
+ let header = BoundedVec {
+ storage: email_circuit_inputs.header_padded,
+ len: parsed_email.canonicalized_header.as_bytes().len(),
+ };
+
+ // Create the BoundedVec for the signature
+ let signature = bn_to_limb_str_array(&signature, Some(MODULUS_BITS));
+
+ // Initialize the NoirCircuitInput struct with required fields
+ let mut noir_circuit_input = NoirCircuitInputs {
+ header,
+ pubkey,
+ signature,
+ dkim_header_sequence,
+ body: None,
+ body_hash_index: None,
+ partial_body_real_length: None,
+ partial_body_hash: None,
+ header_mask: None,
+ body_mask: None,
+ decoded_body: None,
+ from_header_sequence: None,
+ from_address_sequence: None,
+ to_header_sequence: None,
+ to_address_sequence: None,
+ };
+
+ if email_circuit_inputs.body_padded.is_some() {
+ let body_padded = email_circuit_inputs.body_padded.clone().unwrap();
+
+ if params.ignore_body_hash_check.is_some_and(|x| !x) {
+ if email_circuit_inputs.body_hash_idx.is_none() {
+ return Err(anyhow::anyhow!(
+ "Body hash check is enabled but body hash index is missing"
+ ));
+ }
+
+ noir_circuit_input.body = Some(BoundedVec {
+ storage: body_padded.clone(),
+ len: parsed_email.canonicalized_body.len(),
+ });
+ noir_circuit_input.body_hash_index = email_circuit_inputs.body_hash_idx;
+ }
+
+ if params.sha_precompute_selector.is_some() {
+ noir_circuit_input.partial_body_real_length =
+ Some(parsed_email.canonicalized_body.len());
+ let partial_hash = u8_to_u32(email_circuit_inputs.precomputed_sha.unwrap().as_slice())?;
+ noir_circuit_input.partial_body_hash = Some(partial_hash);
+
+ // Calculate remaining body length after SHA cutoff
+ // TODO: This will fail if the selector is not found in the body (i.e selector is without soft line breaks).
+ let selector = params.sha_precompute_selector.unwrap();
+ let selector_bytes = selector.as_bytes();
+ let body_bytes = parsed_email.canonicalized_body.as_bytes();
+ let selector_index = body_bytes
+ .windows(selector_bytes.len())
+ .position(|window| window == selector_bytes)
+ .ok_or_else(|| anyhow::anyhow!("Selector not found in body"))?;
+ let sha_cutoff_index = (selector_index / 64) * 64;
+ let remaining_body_length = body_bytes.len() - sha_cutoff_index;
+ noir_circuit_input.body.as_mut().unwrap().len = remaining_body_length;
+ }
+
+ if params.body_mask.is_some() {
+ noir_circuit_input.body_mask = params.body_mask;
+ }
+
+ if params.remove_soft_line_breaks.is_some_and(|x| x) {
+ let (cleaned_body, index_map) =
+ remove_quoted_printable_soft_breaks(body_padded.clone());
+ noir_circuit_input.decoded_body = Some(BoundedVec {
+ storage: cleaned_body,
+ len: index_map.len(),
+ });
+ }
+ }
+
+ if params.header_mask.is_some() {
+ noir_circuit_input.header_mask = params.header_mask;
+ }
+
+ if params.extract_from.is_some_and(|extract_from| extract_from) {
+ let from_header_sequence =
+ get_address_header_sequence(&parsed_email.canonicalized_header.as_bytes(), "from")?;
+ noir_circuit_input.from_header_sequence = Some(from_header_sequence[0].clone());
+ noir_circuit_input.from_address_sequence = Some(from_header_sequence[1].clone());
+ }
+
+ if params.extract_to.is_some_and(|extract_to| extract_to) {
+ let to_header_sequence =
+ get_address_header_sequence(&parsed_email.canonicalized_header.as_bytes(), "to")?;
+ noir_circuit_input.to_header_sequence = Some(to_header_sequence[0].clone());
+ noir_circuit_input.to_address_sequence = Some(to_header_sequence[1].clone());
+ }
+
+ Ok(noir_circuit_input)
+}
+
+pub async fn generate_noir_circuit_inputs_with_regexes_and_external_inputs(
+ email: &str,
+ regex_inputs: Vec,
+ external_inputs: Vec,
+ params: CircuitInputWithDecomposedRegexesAndExternalInputsParams,
+) -> Result {
+ // Generate basic email circuit inputs first
+ let email_circuit_params = NoirInputGenerationArgs {
+ max_headers_length: Some(params.max_header_length),
+ max_body_length: Some(params.max_body_length),
+ ignore_body_hash_check: Some(params.ignore_body_hash_check),
+ remove_soft_line_breaks: Some(params.remove_soft_line_breaks),
+ sha_precompute_selector: params.sha_precompute_selector,
+ ..Default::default()
+ };
+ let noir_circuit_input = generate_noir_circuit_input(email, email_circuit_params).await?;
+
+ // Convert the NoirCircuitInputs to a JSON Value as the base
+ let mut circuit_inputs = to_json_value(&noir_circuit_input)?;
+
+ // Add prover ethereum address if provided
+ if let Some(prover_eth_address) = ¶ms.prover_eth_address {
+ circuit_inputs["prover_address"] =
+ serde_json::Value::Array(vec![serde_json::Value::String(prover_eth_address.clone())]);
+ } else {
+ circuit_inputs["prover_address"] =
+ serde_json::Value::Array(vec![serde_json::Value::String("0x0".to_string())]);
+ }
+
+ // Process external inputs and add them to the circuit inputs
+ for external_input in external_inputs {
+ // Use the existing utility function to convert the string to a Vec of byte values
+ let mut value_as_byte_strings =
+ string_to_circom_bigint_bytes(&external_input.value.as_deref().unwrap_or(""))?;
+
+ let signal_length = compute_signal_length(external_input.max_length);
+
+ // Pad the Vec with "0" strings if it's shorter than the target length
+ if value_as_byte_strings.len() < signal_length {
+ value_as_byte_strings.extend(
+ std::iter::repeat("0".to_string())
+ .take(signal_length - value_as_byte_strings.len()),
+ );
+ }
+
+ // Convert the Vec to a serde_json::Value::Array of serde_json::Value::String
+ let json_value_array = serde_json::Value::Array(
+ value_as_byte_strings
+ .into_iter()
+ .map(serde_json::Value::String)
+ .collect(),
+ );
+ circuit_inputs[external_input.name] = json_value_array;
+ }
+
+ // Process each regex input
+ for regex_input in regex_inputs {
+ let haystack = match regex_input.haystack_location {
+ HaystackLocation::Header => {
+ let original_bytes =
+ &noir_circuit_input.header.storage[..noir_circuit_input.header.len];
+ let trimmed_bytes = trim_sha256_padding(original_bytes);
+ let haystack_string = String::from_utf8(trimmed_bytes.to_vec())
+ .map_err(|e| anyhow::anyhow!("Failed to convert header to UTF-8: {}", e))?;
+
+ haystack_string
+ }
+ HaystackLocation::Body => {
+ let body = if params.remove_soft_line_breaks {
+ noir_circuit_input.decoded_body.as_ref().unwrap()
+ } else {
+ noir_circuit_input.body.as_ref().unwrap()
+ };
+
+ let original_bytes = &body.storage[..body.len];
+ let trimmed_bytes = trim_sha256_padding(original_bytes);
+ let haystack_string = String::from_utf8(trimmed_bytes.to_vec())
+ .map_err(|e| anyhow::anyhow!("Failed to convert body to UTF-8: {}", e))?;
+
+ haystack_string
+ }
+ };
+
+ // Use zk_regex_compiler to generate regex circuit inputs
+ let regex_result = gen_circuit_inputs(
+ &NFAGraph::from_json(®ex_input.regex_graph_json)?,
+ &haystack,
+ regex_input.max_haystack_length,
+ regex_input.max_match_length,
+ regex_input.proving_framework,
+ )?;
+
+ match regex_result {
+ // Add regex fields to circuit inputs with the regex name as prefix
+ ProverInputs::Noir(noir_inputs) => {
+ circuit_inputs[format!("{}_match_start", regex_input.name)] =
+ serde_json::Value::Number(noir_inputs.match_start.into());
+ circuit_inputs[format!("{}_match_length", regex_input.name)] =
+ serde_json::Value::Number(noir_inputs.match_length.into());
+ circuit_inputs[format!("{}_current_states", regex_input.name)] =
+ serde_json::Value::Array(
+ noir_inputs
+ .curr_states
+ .iter()
+ .map(|s| serde_json::Value::Number((*s as u64).into()))
+ .collect(),
+ );
+ circuit_inputs[format!("{}_next_states", regex_input.name)] =
+ serde_json::Value::Array(
+ noir_inputs
+ .next_states
+ .iter()
+ .map(|s| serde_json::Value::Number((*s as u64).into()))
+ .collect(),
+ );
+
+ // Add capture group fields if they exist
+ if let Some(capture_group_ids) = noir_inputs.capture_group_ids {
+ for (i, id) in capture_group_ids.iter().enumerate() {
+ circuit_inputs
+ [format!("{}_capture_group_{}_id", regex_input.name, i + 1)] =
+ serde_json::Value::Array(
+ id.iter()
+ .map(|s| serde_json::Value::Number((*s as u64).into()))
+ .collect(),
+ );
+ }
+
+ if let Some(capture_group_starts) = noir_inputs.capture_group_starts {
+ for (i, start) in capture_group_starts.iter().enumerate() {
+ circuit_inputs
+ [format!("{}_capture_group_{}_start", regex_input.name, i + 1)] =
+ serde_json::Value::Array(
+ start
+ .iter()
+ .map(|s| serde_json::Value::Number((*s as u64).into()))
+ .collect(),
+ );
+ }
+ } else {
+ return Err(anyhow::anyhow!("Capture group starts are missing"));
+ }
+
+ if let Some(capture_group_indices) = noir_inputs.capture_group_start_indices {
+ circuit_inputs
+ [format!("{}_capture_group_start_indices", regex_input.name)] =
+ serde_json::Value::Array(
+ capture_group_indices
+ .iter()
+ .map(|s| serde_json::Value::Number((*s as u64).into()))
+ .collect(),
+ );
+ } else {
+ return Err(anyhow::anyhow!("Capture group indices are missing"));
+ }
+ }
+ }
+ ProverInputs::Circom(_) => {
+ return Err(anyhow::anyhow!("Circom is not supported yet"));
+ }
+ }
+ }
+
+ Ok(circuit_inputs)
+}
+
+/// Converts a NoirCircuitInputs struct to a JSON Value
+///
+/// This is useful for compatibility with systems expecting JSON output
+pub fn to_json_value(input: &NoirCircuitInputs) -> Result {
+ let json_value = serde_json::to_value(input)?;
+ Ok(json_value)
+}
+
+/// Generates a Noir circuit input and converts it to a JSON Value for backward compatibility
+///
+/// This function maintains compatibility with the original JSON interface
+pub async fn generate_noir_circuit_input_json(
+ email: &str,
+ params: NoirInputGenerationArgs,
+) -> Result {
+ let noir_circuit_input = generate_noir_circuit_input(email, params).await?;
+ to_json_value(&noir_circuit_input)
+}
+
+#[cfg(test)]
+mod tests {
+ use crate::circuit::noir::{
+ generate_noir_circuit_input, generate_noir_circuit_input_json,
+ structs::NoirInputGenerationArgs,
+ };
+ use serde_json::to_string_pretty;
+
+ #[tokio::test]
+ async fn test_generate_noir_circuit_input() {
+ let email = include_str!("../../../tests/fixtures/test.eml");
+ let params = NoirInputGenerationArgs {
+ max_headers_length: Some(576),
+ extract_from: Some(true),
+ ..Default::default()
+ };
+
+ // Test the struct-based approach
+ let noir_circuit_input = generate_noir_circuit_input(email, params.clone())
+ .await
+ .unwrap();
+
+ // Convert to JSON string for debugging
+ let json_output = to_string_pretty(&noir_circuit_input).unwrap();
+ println!(
+ "noir_circuit_input struct converted to JSON: {}",
+ json_output
+ );
+
+ // Test the JSON-based approach for backward compatibility
+ let json_value = generate_noir_circuit_input_json(email, params)
+ .await
+ .unwrap();
+ println!("noir_circuit_input direct JSON: {}", json_value);
+ }
+}
diff --git a/src/circuit/noir/structs.rs b/src/circuit/noir/structs.rs
new file mode 100644
index 0000000..19eccd6
--- /dev/null
+++ b/src/circuit/noir/structs.rs
@@ -0,0 +1,68 @@
+use serde::{Deserialize, Serialize};
+use zk_regex_compiler::ProvingFramework;
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct BoundedVec {
+ pub storage: Vec,
+ pub len: usize,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct Pubkey {
+ pub modulus: Vec,
+ pub redc: Vec,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct Sequence {
+ pub index: usize,
+ pub length: usize,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct NoirCircuitInputs {
+ pub header: BoundedVec,
+ pub pubkey: Pubkey,
+ pub signature: Vec,
+ pub dkim_header_sequence: Sequence,
+ pub body: Option,
+ pub body_hash_index: Option,
+ pub partial_body_real_length: Option,
+ pub partial_body_hash: Option>,
+ pub header_mask: Option>,
+ pub body_mask: Option>,
+ pub decoded_body: Option,
+ pub from_header_sequence: Option,
+ pub from_address_sequence: Option,
+ pub to_header_sequence: Option,
+ pub to_address_sequence: Option,
+}
+
+#[derive(Default, Clone, Debug, Serialize, Deserialize)]
+pub struct NoirInputGenerationArgs {
+ pub ignore_body_hash_check: Option,
+ pub sha_precompute_selector: Option,
+ pub max_headers_length: Option,
+ pub max_body_length: Option,
+ pub remove_soft_line_breaks: Option,
+ pub header_mask: Option>,
+ pub body_mask: Option>,
+ pub extract_from: Option,
+ pub extract_to: Option,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum HaystackLocation {
+ Header,
+ Body,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct RegexInput {
+ pub name: String,
+ pub regex_graph_json: String,
+ pub haystack_location: HaystackLocation,
+ pub max_haystack_length: usize,
+ pub max_match_length: usize,
+ pub proving_framework: ProvingFramework,
+}
diff --git a/src/circuit/noir/utils.rs b/src/circuit/noir/utils.rs
new file mode 100644
index 0000000..81efc80
--- /dev/null
+++ b/src/circuit/noir/utils.rs
@@ -0,0 +1,350 @@
+use anyhow::{anyhow, Ok, Result};
+use num_bigint::BigInt;
+use num_traits::Num;
+use regex::Regex;
+
+use super::structs::Sequence;
+
+/// Computes the Barrett reduction parameter used in Barrett reduction.
+///
+/// # Arguments
+///
+/// * `input` - The input big integer as a reference
+/// * `num_bits` - Optional number of bits in the input
+///
+/// # Returns
+///
+/// The Barrett reduction parameter as a BigInt
+pub fn compute_barrett_reduction_parameter(input: &BigInt, num_bits: Option) -> BigInt {
+ // Determine the bit length if not provided
+ let bits = match num_bits {
+ Some(bits) => {
+ let actual_bits = input.bits() as usize;
+ if actual_bits > bits {
+ panic!("Given bits for bignum limbs is too small");
+ }
+ bits
+ }
+ None => input.bits() as usize,
+ };
+
+ // Compute overflow bits
+ let overflow_bits = 4;
+
+ // multiplicand = 2^(2 * k + overflow_bits)
+ let multiplicand = BigInt::from(1) << (2 * bits + overflow_bits);
+
+ // Compute the Barrett reduction parameter
+ multiplicand / input
+}
+
+/// Splits a BigInt into an array of 120-bit slices.
+///
+/// # Arguments
+///
+/// * `input` - The input big integer to be split
+/// * `num_bits` - The number of bits in the input
+///
+/// # Returns
+///
+/// A vector of BigInt, each representing a 120-bit slice
+pub fn split_into_120bit_limbs(mut input: BigInt, num_bits: usize) -> Vec {
+ const LIMB_BITS: usize = 120;
+ let num_limbs = (num_bits + LIMB_BITS - 1) / LIMB_BITS; // ceiling division
+ let mask = (BigInt::from(1) << LIMB_BITS) - 1;
+
+ let mut limbs = Vec::with_capacity(num_limbs);
+ for _ in 0..num_limbs {
+ let slice = &input & &mask;
+ input >>= LIMB_BITS;
+ limbs.push(slice);
+ }
+
+ limbs
+}
+
+/// Converts a hex string to a BigInt.
+///
+/// # Arguments
+///
+/// * `hex_str` - A hex string, with or without '0x' prefix
+///
+/// # Returns
+///
+/// A Result containing the BigInt or an error
+fn hex_to_bigint(hex_str: &str) -> Result {
+ let clean_hex = if hex_str.to_lowercase().starts_with("0x") {
+ &hex_str[2..]
+ } else {
+ hex_str
+ };
+
+ // Validate hex string
+ if !clean_hex.chars().all(|c| c.is_digit(16)) {
+ return Err(anyhow::anyhow!("Invalid hexadecimal string"));
+ }
+
+ BigInt::from_str_radix(clean_hex, 16)
+ .map_err(|e| anyhow::anyhow!("Failed to parse hex string: {}", e))
+}
+
+/// Converts a BigInt to a vector of hexadecimal strings, each representing a 120-bit limb.
+///
+/// # Arguments
+///
+/// * `input` - The input as either a BigInt reference or a hex string
+/// * `num_bits` - Optional number of bits in the input
+///
+/// # Returns
+///
+/// A Result containing a vector of strings, each representing a 120-bit limb in "0x..." format
+pub fn bn_to_limb_str_array(input: &BigInt, num_bits: Option) -> Vec {
+ // Determine the bit length if not provided
+ let bits = match num_bits {
+ Some(bits) => {
+ let actual_bits = input.bits() as usize;
+ if actual_bits > bits {
+ panic!("Given bits for bignum limbs is too small");
+ }
+ bits
+ }
+ None => input.bits() as usize,
+ };
+
+ // Split into 120-bit limbs
+ let limbs = split_into_120bit_limbs(input.clone(), bits);
+
+ // Convert each limb to a "0x..." hexadecimal string
+ limbs
+ .into_iter()
+ .map(|limb| {
+ // Get the hex representation without the "0x" prefix
+ let hex_string = format!("{:x}", limb);
+
+ // Ensure even length for the hex string
+ let padded_hex = if hex_string.len() % 2 != 0 {
+ format!("0{}", hex_string)
+ } else {
+ hex_string
+ };
+
+ format!("0x{}", padded_hex)
+ })
+ .collect()
+}
+
+/// Converts a hex string to a BigInt and then to limb strings.
+///
+/// # Arguments
+///
+/// * `hex_str` - A hex string
+/// * `num_bits` - Optional number of bits
+///
+/// # Returns
+///
+/// A Result containing a vector of limb strings
+pub fn hex_str_to_limb_str_array(hex_str: &str, num_bits: Option) -> Result> {
+ let bn = hex_to_bigint(hex_str)?;
+ Ok(bn_to_limb_str_array(&bn, num_bits))
+}
+
+/// Compute the Barrett reduction parameter and convert it to an array of 120-bit limbs.
+///
+/// # Arguments
+///
+/// * `input` - The input as either a BigInt reference
+/// * `num_bits` - Optional number of bits in the input
+///
+/// # Returns
+///
+/// A vector of strings, each representing a 120-bit limb in "0x..." format
+pub fn bn_to_redc_limb_str_array(input: &BigInt, num_bits: Option) -> Vec {
+ let redc = compute_barrett_reduction_parameter(input, num_bits);
+ bn_to_limb_str_array(&redc, None)
+}
+
+/// Compute the Barrett reduction parameter from hex string and convert it to limb strings.
+///
+/// # Arguments
+///
+/// * `hex_str` - A hex string
+/// * `num_bits` - Optional number of bits
+///
+/// # Returns
+///
+/// A Result containing a vector of limb strings for the reduction parameter
+pub fn hex_str_to_redc_limb_str_array(
+ hex_str: &str,
+ num_bits: Option,
+) -> Result> {
+ let bn = hex_to_bigint(hex_str)?;
+ let limbs = bn_to_redc_limb_str_array(&bn, num_bits);
+ Ok(limbs)
+}
+
+/// Get the index and length of a header field.
+///
+/// # Arguments
+///
+/// * `header` - The header bytes to search for the field in
+/// * `header_field` - The field name to search for
+///
+/// # Returns
+///
+/// A Sequence containing the index and length of the field
+pub fn get_header_sequence(header: &[u8], header_field: &str) -> Result {
+ // Convert header to string
+ let header_str =
+ std::str::from_utf8(header).map_err(|e| anyhow!("Invalid UTF-8 in header: {}", e))?;
+
+ // Create regex pattern matching the TS implementation
+ let first_char = header_field
+ .chars()
+ .next()
+ .ok_or_else(|| anyhow!("Empty header field name"))?;
+
+ let first_upper = first_char.to_uppercase().collect::();
+ let first_lower = first_char.to_lowercase().collect::();
+
+ let pattern = format!(
+ r"[{}{}]{}:.*(?:\r?\n)?",
+ first_upper,
+ first_lower,
+ &header_field[first_char.len_utf8()..].to_lowercase()
+ );
+
+ let regex = Regex::new(&pattern).map_err(|e| anyhow!("Invalid regex pattern: {}", e))?;
+
+ // Find the match
+ let captures = regex
+ .find(header_str)
+ .ok_or_else(|| anyhow!("Field \"{}\" not found in header", header_field))?;
+
+ // Return the index and length matching TS implementation
+ Ok(Sequence {
+ index: captures.start(),
+ length: captures.end() - captures.start(),
+ })
+}
+
+/// Gets the index and length of both a header field and the email address within it.
+///
+/// This function extracts sequence information for email header fields (like 'From', 'To')
+/// and the email address contained within them.
+///
+/// # Arguments
+/// * `header` - The header bytes to search
+/// * `header_field` - The field name to search for (e.g., "from", "to")
+///
+/// # Returns
+/// * A Result containing an array of two Sequence structs:
+/// - First element: header field position information
+/// - Second element: email address position information
+///
+/// # Errors
+/// * If the header field is not found
+/// * If no email address is found in the field
+/// * If the header contains invalid UTF-8
+pub fn get_address_header_sequence(header: &[u8], header_field: &str) -> Result<[Sequence; 2]> {
+ // Convert header to string
+ let header_str =
+ std::str::from_utf8(header).map_err(|e| anyhow!("Invalid UTF-8 in header: {}", e))?;
+
+ // Create case-insensitive regex pattern for the header field and email address
+ let regex_prefix = regex::escape(header_field);
+ let pattern = format!(
+ r"(?i){}:.*?<([^>]+)>|(?i){}:.*?([a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{{2,}})",
+ regex_prefix, regex_prefix
+ );
+
+ let regex = Regex::new(&pattern).map_err(|e| anyhow!("Invalid regex pattern: {}", e))?;
+
+ // Find the match
+ let captures = regex
+ .captures(header_str)
+ .ok_or_else(|| anyhow!("Field \"{}\" not found in header", header_field))?;
+
+ // Get the overall match
+ let full_match = captures
+ .get(0)
+ .ok_or_else(|| anyhow!("Unexpected regex match structure"))?;
+
+ // Get the email address from either the first or second capture group
+ let address = captures
+ .get(1)
+ .or_else(|| captures.get(2))
+ .ok_or_else(|| anyhow!("Address not found in \"{}\" field", header_field))?;
+
+ // Create the return value
+ let field_sequence = Sequence {
+ index: full_match.start(),
+ length: full_match.end() - full_match.start(),
+ };
+
+ let address_sequence = Sequence {
+ index: address.start(),
+ length: address.end() - address.start(),
+ };
+
+ Ok([field_sequence, address_sequence])
+}
+
+/// Transforms a u8 array to a u32 array in big-endian format.
+///
+/// This function takes a slice of bytes and converts them to a vector of u32 values,
+/// where each u32 is constructed from 4 bytes in big-endian format.
+///
+/// # Arguments
+///
+/// * `input` - A slice of bytes to convert
+///
+/// # Returns
+///
+/// A Result containing either a vector of u32 values or an error
+pub fn u8_to_u32(input: &[u8]) -> Result> {
+ if input.len() % 4 != 0 {
+ return Err(anyhow!("Input length must be a multiple of 4"));
+ }
+
+ let mut output = Vec::with_capacity(input.len() / 4);
+
+ for chunk in input.chunks(4) {
+ let value = u32::from_be_bytes([chunk[0], chunk[1], chunk[2], chunk[3]]);
+ output.push(value);
+ }
+
+ Ok(output)
+}
+
+pub fn trim_sha256_padding(data: &[u8]) -> &[u8] {
+ // SHA256 padding starts with 0x80 byte followed by zeros
+ // Find the last 0x80 byte (padding marker)
+ if let Some(padding_start) = data.iter().rposition(|&b| b == 0x80) {
+ // Check if everything after 0x80 is zeros or length encoding
+ let after_padding = &data[padding_start + 1..];
+
+ // If we find 0x80 and it's followed by zeros/length, return data before padding
+ if after_padding.iter().rev().take(8).all(|&b| b != 0x80) {
+ return &data[..padding_start];
+ }
+ }
+
+ // Fallback: find the last non-zero byte that isn't part of length encoding
+ // SHA256 padding ends with 8-byte length, so check if last 8 bytes look like length
+ if data.len() >= 8 {
+ let (content, potential_length) = data.split_at(data.len() - 8);
+ // If last 8 bytes represent a reasonable length, trim from there
+ if let Some(last_nonzero) = content.iter().rposition(|&b| b != 0) {
+ if content[last_nonzero] == 0x80 {
+ return &content[..last_nonzero];
+ }
+ }
+ }
+
+ // Ultimate fallback: trim trailing zeros
+ if let Some(last_nonzero) = data.iter().rposition(|&b| b != 0) {
+ &data[..=last_nonzero]
+ } else {
+ data
+ }
+}
diff --git a/src/circuit/utils.rs b/src/circuit/utils.rs
new file mode 100644
index 0000000..536cba1
--- /dev/null
+++ b/src/circuit/utils.rs
@@ -0,0 +1,87 @@
+use anyhow::{anyhow, Result};
+use regex::Regex;
+
+/// Finds a selector string in cleaned content and maps it back to its original position.
+///
+/// # Arguments
+/// * `clean_content` - The cleaned content as a slice of bytes (no QP soft line breaks).
+/// * `selector` - The string to find in the cleaned content.
+/// * `position_map` - A slice mapping cleaned indices to original indices.
+/// For each i, `position_map[i]` is the index in `original_body` where that cleaned byte originated.
+/// If `position_map[i]` is `usize::MAX`, that cleaned position has no corresponding original position.
+///
+/// # Returns
+/// A tuple containing `(selector, original_index)`.
+///
+/// # Errors
+/// Returns an error if the selector is not found in the cleaned content or if the position mapping fails.
+pub fn find_selector_in_clean_content(
+ clean_content: &[u8],
+ selector: &str,
+ position_map: &[usize],
+) -> Result<(String, usize, usize)> {
+ let clean_string = String::from_utf8(clean_content.to_vec())?;
+ let re = Regex::new(selector)?;
+ if let Some(m) = re.find(&clean_string) {
+ let selector_start_index = m.start();
+ let selector_end_index = m.end();
+ // Map this cleaned index back to original
+ if selector_start_index < position_map.len() && selector_end_index < position_map.len() {
+ let original_start_index = position_map[selector_start_index];
+ let original_end_index = position_map[selector_end_index];
+ if original_start_index == usize::MAX || original_end_index == usize::MAX {
+ return Err(anyhow!("Failed to map selector position to original body"));
+ }
+ Ok((
+ selector.to_string(),
+ original_start_index,
+ original_end_index,
+ ))
+ } else {
+ Err(anyhow!("Selector index out of range in position map"))
+ }
+ } else {
+ Err(anyhow!(
+ "SHA precompute selector \"{}\" not found in cleaned body",
+ selector
+ ))
+ }
+}
+
+/// Gets the adjusted selector string that accounts for potential soft line breaks in QP encoding.
+/// If the selector exists in the original body, returns it as-is. Otherwise, finds it in cleaned
+/// content and maps it back to the original format, including any soft line breaks.
+///
+/// # Arguments
+/// * `original_body` - The original body as a slice of bytes, possibly containing QP soft line breaks.
+/// * `selector` - The string to find in the content.
+/// * `clean_content` - The cleaned content with soft line breaks removed.
+/// * `position_map` - The index mapping from cleaned content to original content.
+///
+/// # Returns
+/// The adjusted selector string that matches the original body format.
+///
+/// # Errors
+/// Returns an error if the selector cannot be found in either the original or cleaned content.
+pub fn get_adjusted_selector(
+ original_body: &[u8],
+ selector: &str,
+ clean_content: &[u8],
+ position_map: &[usize],
+) -> Result {
+ let original_str = String::from_utf8(original_body.to_vec())?;
+
+ // First, try finding the selector in the original body as-is
+ if original_str.contains(selector) {
+ return Ok(selector.to_string());
+ }
+
+ // If not found, we must find it in the cleaned content and map back to original
+ let (_, original_start_index, original_end_index) =
+ find_selector_in_clean_content(clean_content, selector, position_map)?;
+
+ // Retrieve the substring from the original body that corresponds to the found selector
+ let adjusted_selector = &original_body[original_start_index..original_end_index];
+
+ Ok(String::from_utf8(adjusted_selector.to_vec())?)
+}
diff --git a/src/cryptos.rs b/src/cryptos.rs
index 07c51f4..172dafc 100644
--- a/src/cryptos.rs
+++ b/src/cryptos.rs
@@ -485,7 +485,7 @@ pub fn generate_partial_sha(
// Check if a selector is provided
if let Some(selector) = selector_regex {
// Create a regex pattern from the selector
- let pattern = regex::Regex::new(&selector).unwrap();
+ let pattern = regex::Regex::new(&selector)?;
let body_str = {
// Undo SHA padding
let mut trimmed_body = body.clone();
@@ -495,7 +495,7 @@ pub fn generate_partial_sha(
trimmed_body.pop();
}
- String::from_utf8(trimmed_body).unwrap()
+ String::from_utf8(trimmed_body)?
};
// Find the index of the selector in the body
@@ -512,6 +512,7 @@ pub fn generate_partial_sha(
// Calculate the cutoff index for SHA-256 block size (64 bytes)
let sha_cutoff_index = (selector_index / 64) * 64;
let precompute_text = &body[..sha_cutoff_index];
+ // Will be padded to max_remaining_body_length
let mut body_remaining = body[sha_cutoff_index..].to_vec();
let body_remaining_length = body_length - precompute_text.len();
@@ -720,6 +721,7 @@ async fn fetch_public_keys(email_headers: EmailHeaders) -> Result<(serde_json::V
// Extract From header with better error handling
let from_headers = email_headers
.get_header("From")
+ .or_else(|| email_headers.get_header("from"))
.ok_or_else(|| anyhow::anyhow!("From header not found"))?;
if from_headers.is_empty() {
diff --git a/src/parse_email.rs b/src/parse_email.rs
index 5c0f42d..ae6223f 100644
--- a/src/parse_email.rs
+++ b/src/parse_email.rs
@@ -336,10 +336,6 @@ pub fn remove_quoted_printable_soft_breaks(body: Vec) -> (Vec, Vec Pr
let email_addr = PaddedEmailAddr::from_email_addr(&email_addr);
let account_code = match hex_to_field(&account_code) {
Ok(field) => AccountCode::from(field),
- Err(_) => return Promise::reject(&JsValue::from_str("Failed to parse AccountCode")),
+ Err(_) => {
+ return Promise::reject(&JsValue::from_str("Failed to parse AccountCode"));
+ }
};
let account_salt = match AccountSalt::new(&email_addr, account_code) {
Ok(salt) => salt,
- Err(_) => return Promise::reject(&JsValue::from_str("Failed to generate AccountSalt")),
+ Err(_) => {
+ return Promise::reject(&JsValue::from_str("Failed to generate AccountSalt"));
+ }
};
match to_value(&account_salt) {
Ok(serialized_salt) => Promise::resolve(&serialized_salt),
@@ -246,7 +248,9 @@ pub async fn sha256Pad(data: JsValue, max_sha_bytes: usize) -> Promise {
// Safe conversion of JsValue to Vec
let data_vec: Vec = match from_value(data) {
Ok(vec) => vec,
- Err(e) => return Err(format!("Failed to convert input data: {}", e)),
+ Err(e) => {
+ return Err(format!("Failed to convert input data: {}", e));
+ }
};
// Validate input size
@@ -428,7 +432,9 @@ pub async fn extractRandFromSignature(signautre: Vec) -> Promise {
let cm_rand = match extract_rand_from_signature(&signautre) {
Ok(field) => field,
- Err(_) => return Promise::reject(&JsValue::from_str("Failed to extract randomness")),
+ Err(_) => {
+ return Promise::reject(&JsValue::from_str("Failed to extract randomness"));
+ }
};
match to_value(&field_to_hex(&cm_rand)) {
Ok(serialized_rand) => Promise::resolve(&serialized_rand),
@@ -457,7 +463,9 @@ pub async fn emailAddrCommitWithSignature(email_addr: String, signautre: Vec
let padded_email_addr = PaddedEmailAddr::from_email_addr(&email_addr);
let cm = match padded_email_addr.to_commitment_with_signature(&signautre) {
Ok(cm) => cm,
- Err(_) => return Promise::reject(&JsValue::from_str("Failed to commit email address")),
+ Err(_) => {
+ return Promise::reject(&JsValue::from_str("Failed to commit email address"));
+ }
};
match to_value(&field_to_hex(&cm)) {
@@ -485,7 +493,9 @@ pub async fn bytesToFields(bytes: JsValue) -> Promise {
let bytes: Vec = match from_value(bytes) {
Ok(bytes) => bytes,
- Err(_) => return Promise::reject(&JsValue::from_str("Failed to convert input to bytes")),
+ Err(_) => {
+ return Promise::reject(&JsValue::from_str("Failed to convert input to bytes"));
+ }
};
let fields = bytes_to_fields(&bytes)
.into_iter()
@@ -564,3 +574,67 @@ pub fn extractInvitationCodeWithPrefixIdxes(inputStr: &str) -> Result bool {
Groth16Verifier::verify(proof, public_inputs, sp1_vk_hash, *GROTH16_VK_BYTES).is_ok()
}
+
+#[wasm_bindgen]
+#[allow(non_snake_case)]
+#[cfg(target_arch = "wasm32")]
+/// Generates Noir circuit inputs including regex and external inputs, exposed to WASM.
+///
+/// # Arguments
+///
+/// * `email` - A `String` representing the raw email data.
+/// * `regex_inputs_js` - A `JsValue` representing a `Vec`.
+/// * `external_inputs_js` - A `JsValue` representing a `Vec`.
+/// * `params_js` - A `JsValue` representing `CircuitInputWithDecomposedRegexesAndExternalInputsParams`.
+///
+/// # Returns
+///
+/// A `Promise` that resolves with the serialized JSON `Value` of the circuit inputs or rejects with an error message.
+pub async fn generateNoirCircuitInputsWithRegexesAndExternalInputs(
+ email: String,
+ regex_inputs_js: JsValue,
+ external_inputs_js: JsValue,
+ params_js: JsValue,
+) -> Promise {
+ console_error_panic_hook::set_once();
+
+ let future = async move {
+ // Deserialize inputs from JsValue
+ let regex_inputs: Vec = from_value(regex_inputs_js).map_err(|e| {
+ JsValue::from_str(&format!("Failed to deserialize regex_inputs: {}", e))
+ })?;
+ let external_inputs: Vec = from_value(external_inputs_js).map_err(|e| {
+ JsValue::from_str(&format!("Failed to deserialize external_inputs: {}", e))
+ })?;
+ let params: CircuitInputWithDecomposedRegexesAndExternalInputsParams =
+ from_value(params_js)
+ .map_err(|e| JsValue::from_str(&format!("Failed to deserialize params: {}", e)))?;
+
+ // Call the original async Rust function
+ let circuit_inputs_result = generate_noir_circuit_inputs_with_regexes_and_external_inputs(
+ &email,
+ regex_inputs,
+ external_inputs,
+ params,
+ )
+ .await;
+
+ match circuit_inputs_result {
+ Ok(circuit_inputs) => {
+ // Serialize the successful result (serde_json::Value) to JsValue
+ to_value(&circuit_inputs)
+ .map_err(|e| JsValue::from_str(&format!("Failed to serialize result: {}", e)))
+ }
+ Err(err) => {
+ // Propagate the error from the Rust function
+ Err(JsValue::from_str(&format!(
+ "Failed to generate circuit inputs: {}",
+ err
+ )))
+ }
+ }
+ };
+
+ // Convert the Rust future into a JavaScript Promise
+ future_to_promise(async { future.await })
+}
diff --git a/yarn.lock b/yarn.lock
index 3b8a9e0..e911c0c 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1,54 +1,86 @@
-# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
-# yarn lockfile v1
+# This file is generated by running "yarn install" inside your project.
+# Manual changes might be lost - proceed with caution!
+__metadata:
+ version: 6
+ cacheKey: 8
"@types/bun@latest":
- version "1.1.14"
- resolved "https://registry.yarnpkg.com/@types/bun/-/bun-1.1.14.tgz#587dead368410b281b1bcbfb61d3ce1a07a63234"
- integrity sha512-opVYiFGtO2af0dnWBdZWlioLBoxSdDO5qokaazLhq8XQtGZbY4pY3/JxY8Zdf/hEwGubbp7ErZXoN1+h2yesxA==
+ version: 1.1.14
+ resolution: "@types/bun@npm:1.1.14"
dependencies:
- bun-types "1.1.37"
+ bun-types: 1.1.37
+ checksum: 2ed1cb533af81b399752302fb416d32971f8f478567240c9d39245e57bf9b723461f66672d8ab6b93a1376fedcae31747674afed34a57042bc525c46118ac93e
+ languageName: node
+ linkType: hard
-"@types/node@*":
- version "22.10.2"
- resolved "https://registry.yarnpkg.com/@types/node/-/node-22.10.2.tgz#a485426e6d1fdafc7b0d4c7b24e2c78182ddabb9"
- integrity sha512-Xxr6BBRCAOQixvonOye19wnzyDiUtTeqldOOmj3CkeblonbccA12PFwlufvRdrpjXxqnmUaeiU5EOA+7s5diUQ==
+"@types/node@npm:*":
+ version: 22.10.2
+ resolution: "@types/node@npm:22.10.2"
dependencies:
- undici-types "~6.20.0"
+ undici-types: ~6.20.0
+ checksum: b22401e6e7d1484e437d802c72f5560e18100b1257b9ad0574d6fe05bebe4dbcb620ea68627d1f1406775070d29ace8b6b51f57e7b1c7b8bafafe6da7f29c843
+ languageName: node
+ linkType: hard
-"@types/node@~20.12.8":
- version "20.12.14"
- resolved "https://registry.yarnpkg.com/@types/node/-/node-20.12.14.tgz#0c5cf7ef26aedfd64b0539bba9380ed1f57dcc77"
- integrity sha512-scnD59RpYD91xngrQQLGkE+6UrHUPzeKZWhhjBSa3HSkwjbQc38+q3RoIVEwxQGRw3M+j5hpNAM+lgV3cVormg==
+"@types/node@npm:~20.12.8":
+ version: 20.12.14
+ resolution: "@types/node@npm:20.12.14"
dependencies:
- undici-types "~5.26.4"
+ undici-types: ~5.26.4
+ checksum: f6071bcf87f04f9bcc04d50f5ae2b29bf7d45410390e3ce0a29ed78b2d7420de710f3416f8432541b9f297a344b80c9d570de2848fefe3f801688270fd8ee5a5
+ languageName: node
+ linkType: hard
-"@types/ws@~8.5.10":
- version "8.5.13"
- resolved "https://registry.yarnpkg.com/@types/ws/-/ws-8.5.13.tgz#6414c280875e2691d0d1e080b05addbf5cb91e20"
- integrity sha512-osM/gWBTPKgHV8XkTunnegTRIsvF6owmf5w+JtAfOw472dptdm0dlGv4xCt6GwQRcC2XVOvvRE/0bAoQcL2QkA==
+"@types/ws@npm:~8.5.10":
+ version: 8.5.13
+ resolution: "@types/ws@npm:8.5.13"
dependencies:
- "@types/node" "*"
+ "@types/node": "*"
+ checksum: f17023ce7b89c6124249c90211803a4aaa02886e12bc2d0d2cd47fa665eeb058db4d871ce4397d8e423f6beea97dd56835dd3fdbb921030fe4d887601e37d609
+ languageName: node
+ linkType: hard
-bun-types@1.1.37:
- version "1.1.37"
- resolved "https://registry.yarnpkg.com/bun-types/-/bun-types-1.1.37.tgz#8caab7fa0dd1490a368c5e4dd0614d500e15e7e9"
- integrity sha512-C65lv6eBr3LPJWFZ2gswyrGZ82ljnH8flVE03xeXxKhi2ZGtFiO4isRKTKnitbSqtRAcaqYSR6djt1whI66AbA==
+"@zk-email/relayer-utils@workspace:.":
+ version: 0.0.0-use.local
+ resolution: "@zk-email/relayer-utils@workspace:."
dependencies:
- "@types/node" "~20.12.8"
- "@types/ws" "~8.5.10"
-
-prettier@^3.3.3:
- version "3.4.2"
- resolved "https://registry.yarnpkg.com/prettier/-/prettier-3.4.2.tgz#a5ce1fb522a588bf2b78ca44c6e6fe5aa5a2b13f"
- integrity sha512-e9MewbtFo+Fevyuxn/4rrcDAaq0IYxPGLvObpQjiZBMAzB9IGmzlnG9RZy3FFas+eBMu2vA0CszMeduow5dIuQ==
-
-undici-types@~5.26.4:
- version "5.26.5"
- resolved "https://registry.yarnpkg.com/undici-types/-/undici-types-5.26.5.tgz#bcd539893d00b56e964fd2657a4866b221a65617"
- integrity sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==
-
-undici-types@~6.20.0:
- version "6.20.0"
- resolved "https://registry.yarnpkg.com/undici-types/-/undici-types-6.20.0.tgz#8171bf22c1f588d1554d55bf204bc624af388433"
- integrity sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg==
+ "@types/bun": latest
+ prettier: ^3.3.3
+ peerDependencies:
+ typescript: ^5.0.0
+ languageName: unknown
+ linkType: soft
+
+"bun-types@npm:1.1.37":
+ version: 1.1.37
+ resolution: "bun-types@npm:1.1.37"
+ dependencies:
+ "@types/node": ~20.12.8
+ "@types/ws": ~8.5.10
+ checksum: 21a8d9364d1e411742a488364e79d70622d97e28db4b5a23af01448fa3df6c253e6955ee13ceb8d234043e510bf037cb5427281e76e57e3bf16420407d7cf55d
+ languageName: node
+ linkType: hard
+
+"prettier@npm:^3.3.3":
+ version: 3.4.2
+ resolution: "prettier@npm:3.4.2"
+ bin:
+ prettier: bin/prettier.cjs
+ checksum: 061c84513db62d3944c8dc8df36584dad82883ce4e49efcdbedd8703dce5b173c33fd9d2a4e1725d642a3b713c932b55418342eaa347479bc4a9cca114a04cd0
+ languageName: node
+ linkType: hard
+
+"undici-types@npm:~5.26.4":
+ version: 5.26.5
+ resolution: "undici-types@npm:5.26.5"
+ checksum: 3192ef6f3fd5df652f2dc1cd782b49d6ff14dc98e5dced492aa8a8c65425227da5da6aafe22523c67f035a272c599bb89cfe803c1db6311e44bed3042fc25487
+ languageName: node
+ linkType: hard
+
+"undici-types@npm:~6.20.0":
+ version: 6.20.0
+ resolution: "undici-types@npm:6.20.0"
+ checksum: b7bc50f012dc6afbcce56c9fd62d7e86b20a62ff21f12b7b5cbf1973b9578d90f22a9c7fe50e638e96905d33893bf2f9f16d98929c4673c2480de05c6c96ea8b
+ languageName: node
+ linkType: hard
![](3D"https://www.amazon.com/gp/r.html?C=3D1=)
![3D""](3D"https://m.media-amazon.com/images/G/01/outbound=)
![3D"It](3D"https://m.media-amazon.com/images/G/01/T=)
![3D"Not](3D"https://m.media-amazon.com=)
![](3D"https://www.amazon.com/gp/r.html?C=)
+------=_Part_533333_1464710557.1723770094034--
diff --git a/browser_test/public/vite.svg b/browser_test/public/vite.svg
new file mode 100644
index 0000000..e7b8dfb
--- /dev/null
+++ b/browser_test/public/vite.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/browser_test/public/x.eml b/browser_test/public/x.eml
new file mode 100644
index 0000000..75be0c0
--- /dev/null
+++ b/browser_test/public/x.eml
@@ -0,0 +1,405 @@
+Delivered-To: thezdev1@gmail.com
+Received: by 2002:a05:7208:30c4:b0:a0:251d:5e41 with SMTP id e4csp175734rba;
+ Thu, 19 Jun 2025 04:11:00 -0700 (PDT)
+X-Google-Smtp-Source: AGHT+IEqIGdeTfkTaA0FmCe08u7/OD8Ru1LUIIFHoRSiZxPbItCCdKY7agF6+p8yWEJPI2YH1evl
+X-Received: by 2002:a05:6a00:10c8:b0:748:2ff7:5e22 with SMTP id d2e1a72fcca58-7489cff1950mr24545143b3a.10.1750331459999;
+ Thu, 19 Jun 2025 04:10:59 -0700 (PDT)
+ARC-Seal: i=1; a=rsa-sha256; t=1750331459; cv=none;
+ d=google.com; s=arc-20240605;
+ b=YGPxlFL/PE8FcA3Mm5VMS/Yqny5nXI+ic/pyxui4FvcTQt5Fgrb55rzAmUy1pXWdj6
+ 3i3bwwAL6Ey4wUmaIVHdopLeYdLF9z/u7qZKE7/ZSJxMTFFV3UBQeyuzY0NzTAoIkCYD
+ liYFdggZb28ELmc4o/KuHTSVZZjN/+4d/MtFAspW3O8CfbpL7hksdCyHpzP/cD3s5ywq
+ NQ1uFvp6LJ9RWe1h8w1mjdWJQH3ppXGc6NkJ+e27/0g9FKFU3u0kW+kbV61QAWuoQPw7
+ g7fhIm6ffL3KqEDK8yIIi3/ap+Ra6RTfhoEG5/cRaDpJjjAlSBofQY2V9Hhpe0sKlfUl
+ nylg==
+ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20240605;
+ h=feedback-id:message-id:mime-version:subject:to:from:date
+ :dkim-signature;
+ bh=nQMuQW5OYEIjDAZsqKnZrCfouvj0Gwod2TU3Wsd+et0=;
+ fh=fDYYgXivSc6zTOFPhUG2MdKnqwapTBkpVsOysAWOq8A=;
+ b=cWk0anbItsupTlJoWMOBg40BECJeiX0hTlpE2qM1g/FdYfioEX1YLwhftUmdfinJn8
+ L3WEHf4PI6zKs9fU3oVick6x1YZwLoDV3auVuseco/f0JDhtsJo18sLM60HfnqD/r1d9
+ DgSjcqEPv6YNqiFgGz89G1ZslNAg9egH4ex3ovvEybVYrMgnYZZzRCrLkzKxpd6mMYtv
+ XbTTc0OAADSVplnyou8tvw7tk2taM6erPZ0/6S+N3jkC4Uh90lNWNOVo/pTwDI7J4e4r
+ JCLHoKENpCmugckKdQm4Et9CnQnaFa3QWHD6DZKiyDB4/7jHXguJ9d+L87hrDz3PuW45
+ XEHQ==;
+ dara=google.com
+ARC-Authentication-Results: i=1; mx.google.com;
+ dkim=pass header.i=@x.com header.s=dkim-202308 header.b=F8Ci42hm;
+ spf=pass (google.com: domain of n0258ffc1a1-b6fb81bb1b404dab-thezdev1===gmail.com@bounce.x.com designates 199.59.150.95 as permitted sender) smtp.mailfrom="n0258ffc1a1-b6fb81bb1b404dab-thezdev1===gmail.com@bounce.x.com";
+ dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=x.com
+Return-Path: ![](3D"https://ea.twimg.com/email/self_serve/medi=)