use wasm compiler && bb.js to generate artifacts

Author: olehmisar

src/tasks.ts

@@ -1,3 +1,4 @@
+import type { UltraHonkBackend, UltraPlonkBackend } from "@aztec/bb.js";
 import {
   TASK_CLEAN,
   TASK_COMPILE,
@@ -7,28 +8,62 @@ import { task } from "hardhat/config";
 import { HardhatPluginError } from "hardhat/plugins";
 import { HardhatConfig } from "hardhat/types";
 import { NoirCache } from "./cache";
-import { installBb, installNargo } from "./install";
+import { installNargo } from "./install";
 import { getTarget, ProofFlavor } from "./Noir";
 import { makeRunCommand, PLUGIN_NAME } from "./utils";
 
 task(TASK_COMPILE, "Compile and generate circuits and contracts").setAction(
   async (args, { config }, runSuper) => {
+    const fs = await import("fs");
+    const path = await import("path");
+
     const noirDir = config.paths.noir;
     const targetDir = await getTarget(noirDir);
 
-    const runCommand = makeRunCommand(config.paths.noir);
-
-    const nargoBinary = await installNargo(config.noir.version);
-    const bbBinary = await installBb(config.noir.bbVersion);
-
     await checkNargoWorkspace(config);
     await addGitIgnore(noirDir);
 
     const force = !!args.force;
     const cache = await NoirCache.fromConfig(config);
     if ((await cache.haveSourceFilesChanged()) || force) {
       console.log("Compiling Noir circuits...");
-      await runCommand(`${nargoBinary} compile`);
+      const { compile, createFileManager } = await import(
+        "@noir-lang/noir_wasm"
+      );
+      const toml = await import("smol-toml");
+
+      // list dirs
+      const dirs = (
+        (
+          toml.parse(
+            fs.readFileSync(path.join(noirDir, "Nargo.toml"), "utf-8"),
+          ) as any
+        ).workspace.members as string[]
+      ).map((dir: string) => path.join(noirDir, dir));
+
+      await Promise.all(
+        dirs.map(async (dir) => {
+          const fileManager = createFileManager(dir);
+          const compiled = await compile(fileManager);
+          const name: unknown = (
+            toml.parse(
+              fs.readFileSync(path.join(dir, "Nargo.toml"), "utf-8"),
+            ) as any
+          ).package?.name;
+          if (typeof name !== "string") {
+            throw new HardhatPluginError(
+              PLUGIN_NAME,
+              `Nargo.toml must contain a name, but ${dir}/Nargo.toml does not`,
+            );
+          }
+          fs.mkdirSync(targetDir, { recursive: true });
+          fs.writeFileSync(
+            path.join(targetDir, `${name}.json`),
+            JSON.stringify(compiled.program, null, 2),
+          );
+        }),
+      );
+
       await cache.saveSourceFilesHash();
       console.log("Compiled Noir circuits");
     }
@@ -45,13 +80,7 @@ task(TASK_COMPILE, "Compile and generate circuits and contracts").setAction(
           if (!config.noir.flavor.includes(flavor)) {
             continue;
           }
-          await generateSolidityVerifier(
-            config,
-            file,
-            bbBinary,
-            targetDir,
-            flavor,
-          );
+          await generateSolidityVerifier(file, targetDir, flavor);
         }
         await cache.saveJsonFileHash(file);
       }),
@@ -108,43 +137,44 @@ task(
 );
 
 async function generateSolidityVerifier(
-  config: HardhatConfig,
   file: string,
-  bbBinary: string,
   targetDir: string,
   flavor: ProofFlavor,
 ) {
   const path = await import("path");
+  const fs = await import("fs");
+  const { UltraHonkBackend, UltraPlonkBackend } = await import("@aztec/bb.js");
 
-  const runCommand = makeRunCommand(config.paths.noir);
-
-  const name = path.basename(file, ".json");
-  console.log(`Generating Solidity ${flavor} verifier for ${name}...`);
-  let writeVkCmd: string, contractCmd: string;
+  let backend: UltraHonkBackend | UltraPlonkBackend;
+  const program = JSON.parse(fs.readFileSync(file, "utf-8"));
   switch (flavor) {
     case "ultra_plonk": {
-      writeVkCmd = "write_vk";
-      contractCmd = "contract";
+      backend = new UltraPlonkBackend(program.bytecode);
       break;
     }
     case "ultra_keccak_honk": {
-      writeVkCmd = "write_vk_ultra_keccak_honk";
-      contractCmd = "contract_ultra_honk";
+      backend = new UltraHonkBackend(program.bytecode);
       break;
     }
     default: {
       flavor satisfies never;
-      return;
+      throw new HardhatPluginError(
+        PLUGIN_NAME,
+        `Unsupported Noir proof flavor: ${flavor}`,
+      );
     }
   }
+  let verifier = await backend.getSolidityVerifier();
+  if (typeof verifier !== "string") {
+    // bug in bb types
+    verifier = new TextDecoder().decode(verifier);
+  }
+
+  const name = path.basename(file, ".json");
+  console.log(`Generating Solidity ${flavor} verifier for ${name}...`);
   const nameSuffix =
     flavor === ProofFlavor.ultra_keccak_honk ? "" : `_${flavor}`;
-  await runCommand(
-    `${bbBinary} ${writeVkCmd} -b ${targetDir}/${name}.json -o ${targetDir}/${name}${nameSuffix}_vk`,
-  );
-  await runCommand(
-    `${bbBinary} ${contractCmd} -k ${targetDir}/${name}${nameSuffix}_vk -o ${targetDir}/${name}${nameSuffix}.sol`,
-  );
+  fs.writeFileSync(path.join(targetDir, `${name}${nameSuffix}.sol`), verifier);
   console.log(`Generated Solidity ${flavor} verifier for ${name}`);
 }