feat: noir_wasm compilation of noir programs

yarn-project/cli/src/index.ts

@@ -20,7 +20,7 @@ import { JsonStringify } from '@aztec/foundation/json-rpc';
 import { DebugLogger, LogFn } from '@aztec/foundation/log';
 import { sleep } from '@aztec/foundation/sleep';
 import { fileURLToPath } from '@aztec/foundation/url';
-import { compileContract, generateNoirInterface, generateTypescriptInterface } from '@aztec/noir-compiler/cli';
+import { compileNoir, generateNoirInterface, generateTypescriptInterface } from '@aztec/noir-compiler/cli';
 import { CompleteAddress, ContractData, ExtendedNote, LogFilter } from '@aztec/types';
 
 import { createSecp256k1PeerId } from '@libp2p/peer-id-factory';
@@ -740,7 +740,7 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command {
       await update(projectPath, contract, options.rpcUrl, options.sandboxVersion, log, debugLogger);
     });
 
-  compileContract(program, 'compile', log);
+  compileNoir(program, 'compile', log);
   generateTypescriptInterface(program, 'generate-typescript', log);
   generateNoirInterface(program, 'generate-noir-interface', log);
 

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

@@ -3,7 +3,7 @@ import { createConsoleLogger } from '@aztec/foundation/log';
 
 import { Command } from 'commander';
 
-import { compileContract } from './cli/contract.js';
+import { compileNoir } from './cli/compileNoir.js';
 import { generateNoirInterface } from './cli/noir-interface.js';
 import { generateTypescriptInterface } from './cli/typescript.js';
 
@@ -12,7 +12,7 @@ const log = createConsoleLogger('aztec:compiler-cli');
 
 const main = async () => {
   program.name('aztec-compile');
-  compileContract(program, 'contract', log);
+  compileNoir(program, 'compile', log);
   generateTypescriptInterface(program, 'typescript', log);
   generateNoirInterface(program, 'interface', log);
   await program.parseAsync(process.argv);

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

@@ -0,0 +1,141 @@
+import { ContractArtifact } from '@aztec/foundation/abi';
+import { LogFn } from '@aztec/foundation/log';
+
+import { Command } from 'commander';
+import { mkdirSync, writeFileSync } from 'fs';
+import { mkdirpSync } from 'fs-extra';
+import path, { resolve } from 'path';
+
+import {
+  ProgramArtifact,
+  compileUsingNargo,
+  compileUsingNoirWasm,
+  generateNoirContractInterface,
+  generateTypescriptContractInterface,
+  generateTypescriptProgramInterface,
+} 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 compileNoir(program: Command, name = 'compile', log: LogFn = () => {}): Command {
+  return program
+    .command(name)
+    .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 Noir Source in the target project')
+
+    .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 ${projectPath} with ${compiler} backend...`);
+      const results = await compile(projectPath, { log });
+      for (const result of results) {
+        generateOutput(projectPath, result, options, log);
+      }
+    });
+}
+
+/**
+ *
+ * @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, program: ProgramArtifact, options: options, log: LogFn) {
+  const currentDir = process.cwd();
+  const { outdir, typescript, interface: noirInterface } = options;
+  const artifactPath = resolve(projectPath, outdir, `${program.name ? program.name : 'main'}.json`);
+  log(`Writing ${program.name} artifact to ${path.relative(currentDir, artifactPath)}`);
+  mkdirSync(path.dirname(artifactPath), { recursive: true });
+  writeFileSync(artifactPath, JSON.stringify(program, null, 2));
+
+  if (noirInterface) {
+    log(`noirInterface generation not implemented for programs`);
+    // not implemented
+  }
+
+  if (typescript) {
+    // just need type definitions, since a lib has just one entry point
+    const tsPath = resolve(projectPath, typescript, `../types/${program.name}_types.ts`);
+    log(`Writing ${program.name} typescript types to ${path.relative(currentDir, tsPath)}`);
+    const tsWrapper = generateTypescriptProgramInterface(program.abi);
+    mkdirpSync(path.dirname(tsPath));
+    writeFileSync(tsPath, tsWrapper);
+  }
+}
+
+/**
+ *
+ * @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 (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);
+    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`;
+    }
+    const tsWrapper = generateTypescriptContractInterface(contract, relativeArtifactPath);
+    mkdirpSync(path.dirname(tsPath));
+    writeFileSync(tsPath, tsWrapper);
+  }
+}

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

@@ -1,3 +1,3 @@
-export { compileContract } from './contract.js';
+export { compileNoir } from './compileNoir.js';
 export { generateNoirInterface } from './noir-interface.js';
 export { generateTypescriptInterface } from './typescript.js';

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(),