feat: noir_wasm compilation of noir programs

barretenberg/cpp/src/barretenberg/relations/relation_types.hpp

@@ -23,10 +23,10 @@ using GetParameterView = std::conditional_t<IsField<typename Params::DataType>,
 
 template <typename T, size_t subrelation_idx>
 concept HasSubrelationLinearlyIndependentMember = requires(T) {
-                                                      {
-                                                          std::get<subrelation_idx>(T::SUBRELATION_LINEARLY_INDEPENDENT)
-                                                          } -> std::convertible_to<bool>;
-                                                  };
+    {
+        std::get<subrelation_idx>(T::SUBRELATION_LINEARLY_INDEPENDENT)
+    } -> std::convertible_to<bool>;
+};
 
 template <typename T>
 concept HasParameterLengthAdjustmentsMember = requires { T::TOTAL_LENGTH_ADJUSTMENTS; };

barretenberg/cpp/src/barretenberg/relations/utils.hpp

@@ -86,8 +86,7 @@ template <typename Flavor> class RelationUtils {
     template <typename... T>
     static constexpr void add_tuples(std::tuple<T...>& tuple_1, const std::tuple<T...>& tuple_2)
     {
-        auto add_tuples_helper = [&]<std::size_t... I>(std::index_sequence<I...>)
-        {
+        auto add_tuples_helper = [&]<std::size_t... I>(std::index_sequence<I...>) {
             ((std::get<I>(tuple_1) += std::get<I>(tuple_2)), ...);
         };
 

yarn-project/noir-compiler/src/cli.ts

@@ -12,7 +12,7 @@ const log = createConsoleLogger('aztec:compiler-cli');
 
 const main = async () => {
   program.name('aztec-compile');
-  compileContract(program, 'contract', log);
+  compileContract(program, 'compile', log);
   generateTypescriptInterface(program, 'typescript', log);
   generateNoirInterface(program, 'interface', log);
   await program.parseAsync(process.argv);

yarn-project/noir-compiler/src/cli/contract.ts

@@ -1,3 +1,4 @@
+import { ContractArtifact } from '@aztec/foundation/abi';
 import { LogFn } from '@aztec/foundation/log';
 
 import { Command } from 'commander';
@@ -6,81 +7,130 @@ import { mkdirpSync } from 'fs-extra';
 import path, { resolve } from 'path';
 
 import {
+  ProgramArtifact,
   compileUsingNargo,
   compileUsingNoirWasm,
   generateNoirContractInterface,
   generateTypescriptContractInterface,
 } from '../index.js';
 
+/**
+ * CLI options for configuring behavior
+ */
+interface options {
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  outdir: string;
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  typescript: string | undefined;
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  interface: string | undefined;
+  // eslint-disable-next-line jsdoc/require-jsdoc
+  compiler: string | undefined;
+}
 /**
  * Registers a 'contract' command on the given commander program that compiles an Aztec.nr contract project.
  * @param program - Commander program.
  * @param log - Optional logging function.
  * @returns The program with the command registered.
  */
-export function compileContract(program: Command, name = 'contract', log: LogFn = () => {}): Command {
+export function compileContract(program: Command, name = 'compile', log: LogFn = () => {}): Command {
   return program
     .command(name)
-    .argument('<project-path>', 'Path to the Aztec.nr project to compile')
+    .argument('<project-path>', 'Path to the bin or Aztec.nr project to compile')
     .option('-o, --outdir <path>', 'Output folder for the binary artifacts, relative to the project path', 'target')
     .option('-ts, --typescript <path>', 'Optional output folder for generating typescript wrappers', undefined)
     .option('-i, --interface <path>', 'Optional output folder for generating an Aztec.nr contract interface', undefined)
     .option('-c --compiler <string>', 'Which compiler to use. Either nargo or wasm. Defaults to nargo', 'wasm')
-    .description('Compiles the contracts in the target project')
+    .description('Compiles the Noir Source in the target project')
 
-    .action(
-      async (
-        projectPath: string,
-        /* eslint-disable jsdoc/require-jsdoc */
-        options: {
-          outdir: string;
-          typescript: string | undefined;
-          interface: string | undefined;
-          compiler: string | undefined;
-        },
-        /* eslint-enable jsdoc/require-jsdoc */
-      ) => {
-        const { outdir, typescript, interface: noirInterface, compiler } = options;
-        if (typeof projectPath !== 'string') throw new Error(`Missing project path argument`);
-        if (compiler !== 'nargo' && compiler !== 'wasm') throw new Error(`Invalid compiler: ${compiler}`);
-        const currentDir = process.cwd();
+    .action(async (projectPath: string, options: options) => {
+      const { compiler } = options;
+      if (typeof projectPath !== 'string') throw new Error(`Missing project path argument`);
+      if (compiler !== 'nargo' && compiler !== 'wasm') throw new Error(`Invalid compiler: ${compiler}`);
 
-        const compile = compiler === 'wasm' ? compileUsingNoirWasm : compileUsingNargo;
-        log(`Compiling contracts...`);
-        const result = await compile(projectPath, { log });
+      const compile = compiler === 'wasm' ? compileUsingNoirWasm : compileUsingNargo;
+      log(`Compiling ${projectPath} with ${compiler} backend...`);
+      const results = await compile(projectPath, { log });
+      for (const result of results) {
+        generateOutput(projectPath, result, options, log);
+      }
+    });
+}
 
-        for (const contract of result) {
-          const artifactPath = resolve(projectPath, outdir, `${contract.name}.json`);
-          log(`Writing ${contract.name} artifact to ${path.relative(currentDir, artifactPath)}`);
-          mkdirSync(path.dirname(artifactPath), { recursive: true });
-          writeFileSync(artifactPath, JSON.stringify(contract, null, 2));
+/**
+ *
+ * @param contract - output from compiler, to serialize locally.  branch based on Contract vs Program
+ */
+function generateOutput(
+  projectPath: string,
+  _result: ContractArtifact | ProgramArtifact,
+  options: options,
+  log: LogFn,
+) {
+  const contract = _result as ContractArtifact;
+  if (contract.name) {
+    return generateContractOutput(projectPath, contract, options, log);
+  } else {
+    const program = _result as ProgramArtifact;
+    if (program.abi) {
+      return generateProgramOutput(projectPath, program, options, log);
+    }
+  }
+}
+/**
+ *
+ * @param program - output from compiler, to serialize locally
+ */
+function generateProgramOutput(projectPath: string, contract: ProgramArtifact, options: options, log: LogFn) {
+  const currentDir = process.cwd();
+  const { outdir, typescript, interface: noirInterface } = options;
+  const artifactPath = resolve(projectPath, outdir, `main.json`);
+  log(`Writing ${'main.json'} artifact to ${path.relative(currentDir, artifactPath)}`);
+  mkdirSync(path.dirname(artifactPath), { recursive: true });
+  writeFileSync(artifactPath, JSON.stringify(contract, null, 2));
+
+  if (noirInterface) {
+    // not implemented
+  }
+
+  if (typescript) {
+    // not implemented
+  }
+}
+
+/**
+ *
+ * @param contract - output from compiler, to serialize locally
+ */
+function generateContractOutput(projectPath: string, contract: ContractArtifact, options: options, log: LogFn) {
+  const currentDir = process.cwd();
+  const { outdir, typescript, interface: noirInterface } = options;
+  const artifactPath = resolve(projectPath, outdir, `${contract.name}.json`);
+  log(`Writing ${contract.name} artifact to ${path.relative(currentDir, artifactPath)}`);
+  mkdirSync(path.dirname(artifactPath), { recursive: true });
+  writeFileSync(artifactPath, JSON.stringify(contract, null, 2));
 
-          if (noirInterface) {
-            const noirInterfacePath = resolve(projectPath, noirInterface, `${contract.name}_interface.nr`);
-            log(
-              `Writing ${contract.name} Aztec.nr external interface to ${path.relative(currentDir, noirInterfacePath)}`,
-            );
-            const noirWrapper = generateNoirContractInterface(contract);
-            mkdirpSync(path.dirname(noirInterfacePath));
-            writeFileSync(noirInterfacePath, noirWrapper);
-          }
+  if (noirInterface) {
+    const noirInterfacePath = resolve(projectPath, noirInterface, `${contract.name}_interface.nr`);
+    log(`Writing ${contract.name} Aztec.nr external interface to ${path.relative(currentDir, noirInterfacePath)}`);
+    const noirWrapper = generateNoirContractInterface(contract);
+    mkdirpSync(path.dirname(noirInterfacePath));
+    writeFileSync(noirInterfacePath, noirWrapper);
+  }
 
-          if (typescript) {
-            const tsPath = resolve(projectPath, typescript, `${contract.name}.ts`);
-            log(`Writing ${contract.name} typescript interface to ${path.relative(currentDir, tsPath)}`);
-            let relativeArtifactPath = path.relative(path.dirname(tsPath), artifactPath);
-            log(`Relative path: ${relativeArtifactPath}`);
-            if (relativeArtifactPath === `${contract.name}.json`) {
-              // relative path edge case, prepending ./ for local import - the above logic just does
-              // `${contract.name}.json`, which is not a valid import for a file in the same directory
-              relativeArtifactPath = `./${contract.name}.json`;
-            }
-            log(`Relative path after correction: ${relativeArtifactPath}`);
-            const tsWrapper = generateTypescriptContractInterface(contract, relativeArtifactPath);
-            mkdirpSync(path.dirname(tsPath));
-            writeFileSync(tsPath, tsWrapper);
-          }
-        }
-      },
-    );
+  if (typescript) {
+    const tsPath = resolve(projectPath, typescript, `${contract.name}.ts`);
+    log(`Writing ${contract.name} typescript interface to ${path.relative(currentDir, tsPath)}`);
+    let relativeArtifactPath = path.relative(path.dirname(tsPath), artifactPath);
+    log(`Relative path: ${relativeArtifactPath}`);
+    if (relativeArtifactPath === `${contract.name}.json`) {
+      // relative path edge case, prepending ./ for local import - the above logic just does
+      // `${contract.name}.json`, which is not a valid import for a file in the same directory
+      relativeArtifactPath = `./${contract.name}.json`;
+    }
+    log(`Relative path after correction: ${relativeArtifactPath}`);
+    const tsWrapper = generateTypescriptContractInterface(contract, relativeArtifactPath);
+    mkdirpSync(path.dirname(tsPath));
+    writeFileSync(tsPath, tsWrapper);
+  }
 }

yarn-project/noir-compiler/src/compile/nargo.ts

@@ -6,7 +6,7 @@ import { emptyDirSync } from 'fs-extra';
 import path from 'path';
 
 import { NoirCommit, NoirTag } from '../index.js';
-import { NoirCompilationArtifacts, NoirCompiledContract, NoirDebugMetadata } from '../noir_artifact.js';
+import { NoirCompiledContract, NoirContractCompilationArtifacts, NoirDebugMetadata } from '../noir_artifact.js';
 
 /** Compilation options */
 export type CompileOpts = {
@@ -31,7 +31,7 @@ export class NargoContractCompiler {
    * Compiles the contracts in projectPath and returns the Aztec.nr artifact.
    * @returns Aztec.nr artifact of the compiled contracts.
    */
-  public compile(): Promise<NoirCompilationArtifacts[]> {
+  public compile(): Promise<NoirContractCompilationArtifacts[]> {
     const stdio = this.opts.quiet ? 'ignore' : 'inherit';
     const nargoBin = this.opts.nargoBin ?? 'nargo';
     const version = execSync(`${nargoBin} --version`, { cwd: this.projectPath, stdio: 'pipe' }).toString();
@@ -51,7 +51,7 @@ export class NargoContractCompiler {
     }
   }
 
-  private collectArtifacts(): NoirCompilationArtifacts[] {
+  private collectArtifacts(): NoirContractCompilationArtifacts[] {
     const contractArtifacts = new Map<string, NoirCompiledContract>();
     const debugArtifacts = new Map<string, NoirDebugMetadata>();
 

yarn-project/noir-compiler/src/compile/noir/noir-wasm-compiler.ts

@@ -3,7 +3,7 @@ import { LogFn, createDebugLogger } from '@aztec/foundation/log';
 import { CompileError, compile } from '@noir-lang/noir_wasm';
 import { isAbsolute } from 'node:path';
 
-import { NoirCompilationArtifacts } from '../../noir_artifact.js';
+import { NoirCompilationResult, NoirProgramCompilationArtifacts } from '../../noir_artifact.js';
 import { NoirDependencyManager } from './dependencies/dependency-manager.js';
 import { GithubDependencyResolver as GithubCodeArchiveDependencyResolver } from './dependencies/github-dependency-resolver.js';
 import { LocalDependencyResolver } from './dependencies/local-dependency-resolver.js';
@@ -54,9 +54,6 @@ export class NoirWasmContractCompiler {
     }
 
     const noirPackage = NoirPackage.open(projectPath, fileManager);
-    if (noirPackage.getType() !== 'contract') {
-      throw new Error('This is not a contract project');
-    }
 
     const dependencyManager = new NoirDependencyManager(
       [
@@ -80,22 +77,73 @@ export class NoirWasmContractCompiler {
   }
 
   /**
-   * Compiles the project.
+   * Compile EntryPoint
    */
-  public async compile(): Promise<NoirCompilationArtifacts[]> {
-    const isContract = this.#package.getType() === 'contract';
-    // limit to contracts-only because the rest of the pipeline only supports processing contracts
-    if (!isContract) {
-      throw new Error('Noir project is not a contract');
+  public async compile(): Promise<NoirCompilationResult[]> {
+    if (this.#package.getType() === 'contract') {
+      this.#debugLog(`Compiling Contract at ${this.#package.getEntryPointPath()}`);
+      return await this.compileContract();
+    } else if (this.#package.getType() === 'bin') {
+      this.#debugLog(`Compiling Program at ${this.#package.getEntryPointPath()}`);
+      return await this.compileProgram();
+    } else {
+      this.#log(
+        `Compile skipped - only supports compiling "contract" and "bin" package types (${this.#package.getType()})`,
+      );
+      return [];
     }
+  }
+
+  /**
+   * Compiles the Program.
+   */
+  public async compileProgram(): Promise<NoirProgramCompilationArtifacts[]> {
+    await this.#dependencyManager.resolveDependencies();
+    this.#debugLog(`Dependencies: ${this.#dependencyManager.getPackageNames().join(', ')}`);
+
+    initializeResolver(this.#resolveFile);
 
+    try {
+      const isContract: boolean = false;
+      const result = compile(this.#package.getEntryPointPath(), isContract, {
+        /* eslint-disable camelcase */
+        root_dependencies: this.#dependencyManager.getEntrypointDependencies(),
+        library_dependencies: this.#dependencyManager.getLibraryDependencies(),
+        /* eslint-enable camelcase */
+      });
+
+      if (!('program' in result)) {
+        throw new Error('No program found in compilation result');
+      }
+
+      return [{ name: this.#package.getNoirPackageConfig().package.name, ...result }];
+    } catch (err) {
+      if (err instanceof Error && err.name === 'CompileError') {
+        this.#processCompileError(err as CompileError);
+      }
+
+      throw err;
+    }
+  }
+
+  /**
+   * Compiles the Contract.
+   */
+  public async compileContract(): Promise<NoirCompilationResult[]> {
+    if (!(this.#package.getType() === 'contract' || this.#package.getType() === 'bin')) {
+      this.#log(
+        `Compile skipped - only supports compiling "contract" and "bin" package types (${this.#package.getType()})`,
+      );
+      return [];
+    }
     this.#debugLog(`Compiling contract at ${this.#package.getEntryPointPath()}`);
     await this.#dependencyManager.resolveDependencies();
     this.#debugLog(`Dependencies: ${this.#dependencyManager.getPackageNames().join(', ')}`);
 
     initializeResolver(this.#resolveFile);
 
     try {
+      const isContract: boolean = true; // this.#package.getType() === 'contract';
       const result = compile(this.#package.getEntryPointPath(), isContract, {
         /* eslint-disable camelcase */
         root_dependencies: this.#dependencyManager.getEntrypointDependencies(),

yarn-project/noir-compiler/src/compile/noir/package.ts

@@ -29,6 +29,13 @@ export class NoirPackage {
     return this.#packagePath;
   }
 
+  /**
+   * Gets this package's Nargo.toml (NoirPackage)Config.
+   */
+  public getNoirPackageConfig() {
+    return this.#config;
+  }
+
   /**
    * The path to the source directory.
    */
@@ -44,6 +51,8 @@ export class NoirPackage {
 
     switch (this.getType()) {
       case 'lib':
+        // we shouldn't need to compile `lib` type, since the .nr source is read directly
+        // when the lib is used as a dependency elsewhere.
         entrypoint = 'lib.nr';
         break;
       case 'contract':