feat: devex improvements to noirjs

compiler/integration-tests/test/browser/compile_prove_verify.test.ts

@@ -62,7 +62,7 @@ test_cases.forEach((testInfo) => {
     }
 
     const backend = new BarretenbergBackend(noir_program);
-    const program = new Noir(noir_program, backend);
+    const program = new Noir(backend);
 
     const prover_toml = await getFile(`${base_relative_path}/${test_case}/Prover.toml`);
     const inputs: InputMap = TOML.parse(prover_toml) as InputMap;

compiler/integration-tests/test/browser/recursion.test.ts

@@ -42,6 +42,8 @@ describe('It compiles noir program code, receiving circuit bytes and abi object.
   let circuit_main_toml;
   let circuit_recursion_source;
 
+  const noir = new Noir(); // backendless noir
+
   before(async () => {
     circuit_main_source = await getFile(`${base_relative_path}/${circuit_main}/src/main.nr`);
     circuit_main_toml = await getFile(`${base_relative_path}/${circuit_main}/Prover.toml`);
@@ -55,7 +57,7 @@ describe('It compiles noir program code, receiving circuit bytes and abi object.
 
     const main_backend = new BarretenbergBackend(main_program);
 
-    const { witness: main_witnessUint8Array } = await new Noir(main_program).execute(main_inputs);
+    const { witness: main_witnessUint8Array } = await noir.execute(main_inputs, main_program);
 
     const main_proof = await main_backend.generateIntermediateProof(main_witnessUint8Array);
     const main_verification = await main_backend.verifyIntermediateProof(main_proof);
@@ -84,7 +86,7 @@ describe('It compiles noir program code, receiving circuit bytes and abi object.
 
     const recursion_backend = new BarretenbergBackend(recursion_program);
 
-    const { witness: recursion_witnessUint8Array } = await new Noir(recursion_program).execute(recursion_inputs);
+    const { witness: recursion_witnessUint8Array } = await new Noir().execute(recursion_inputs, recursion_program);
 
     const recursion_proof = await recursion_backend.generateFinalProof(recursion_witnessUint8Array);
 

compiler/integration-tests/test/node/smart_contract_verifier.test.ts

@@ -36,7 +36,7 @@ test_cases.forEach((testInfo) => {
     const noir_program = compile(noir_source_path);
 
     const backend = new BarretenbergBackend(noir_program);
-    const program = new Noir(noir_program, backend);
+    const program = new Noir(backend);
 
     // JS Proving
 

tooling/noir_js/src/index.ts

@@ -1,8 +1,59 @@
-import * as acvm from '@noir-lang/acvm_js';
-import * as abi from '@noir-lang/noirc_abi';
+/* eslint-disable  @typescript-eslint/no-explicit-any */
+import { Backend, CompiledCircuit, ProofData } from '@noir-lang/types';
+import { generateWitness } from './witness_generation.js';
+import initAbi, * as abi from '@noir-lang/noirc_abi';
+import initACVM, * as acvm from '@noir-lang/acvm_js';
+import { witnessMapToUint8Array } from './serialize.js';
 
-export { acvm, abi };
+const { abiDecode } = abi;
 
-export { acirToUint8Array, witnessMapToUint8Array } from './serialize.js';
+class Noir {
+  constructor(private backend?: Backend) {}
 
-export { Noir } from './program.js';
+  async init(): Promise<void> {
+    // If these are available, then we are in the
+    // web environment. For the node environment, this
+    // is a no-op.
+    if (typeof initAbi === 'function') {
+      await Promise.all([initAbi(), initACVM()]);
+    }
+  }
+
+  async destroy(): Promise<void> {
+    if (!this.backend) throw new Error('No backend to destroy');
+
+    await this.backend.destroy();
+  }
+
+  private getBackend(): Backend {
+    if (this.backend === undefined) throw new Error('Operation requires a backend but none was provided');
+    return this.backend;
+  }
+
+  // Initial inputs to your program
+  async execute(
+    inputs: abi.InputMap,
+    circuit?: CompiledCircuit,
+  ): Promise<{ witness: Uint8Array; returnValue: abi.InputValue }> {
+    if (!circuit && !this.backend) throw new Error('Operation requires a circuit or a backend, but none was provided');
+
+    await this.init();
+    const witness = await generateWitness(circuit!, inputs);
+    const { return_value: returnValue } = abiDecode(circuit!.abi, witness);
+    return { witness: witnessMapToUint8Array(witness), returnValue };
+  }
+
+  // Initial inputs to your program
+  async generateFinalProof(inputs: abi.InputMap): Promise<ProofData> {
+    if (!this.backend) throw new Error('Operation requires a backend but none was provided');
+
+    const { witness } = await this.execute(inputs, this.backend.circuit);
+    return this.getBackend().generateFinalProof(witness);
+  }
+
+  async verifyFinalProof(proofData: ProofData): Promise<boolean> {
+    return this.getBackend().verifyFinalProof(proofData);
+  }
+}
+
+export { Noir, acvm, abi };

tooling/noir_js/test/node/cjs.test.cjs

@@ -4,12 +4,14 @@ const chai = require('chai');
 const assert_lt_json = require('../noir_compiled_examples/assert_lt/target/assert_lt.json');
 const { Noir } = require('@noir-lang/noir_js');
 
+const assert_lt_program = assert_lt_json;
+
 it('generates witnesses successfully', async () => {
   const inputs = {
     x: '2',
     y: '3',
   };
-  const _solvedWitness = await new Noir(assert_lt_json).execute(inputs);
+  const _solvedWitness = await new Noir(assert_lt_json).execute(inputs, assert_lt_program);
 });
 
 it('string input and number input are the same', async () => {
@@ -21,8 +23,8 @@ it('string input and number input are the same', async () => {
     x: 2,
     y: 3,
   };
-  const solvedWitnessString = await new Noir(assert_lt_json).execute(inputsString);
-  const solvedWitnessNumber = await new Noir(assert_lt_json).execute(inputsNumber);
+  const solvedWitnessString = await new Noir(assert_lt_json).execute(inputsString, assert_lt_program);
+  const solvedWitnessNumber = await new Noir(assert_lt_json).execute(inputsNumber, assert_lt_program);
   chai.expect(solvedWitnessString).to.deep.equal(solvedWitnessNumber);
 });
 
@@ -36,8 +38,8 @@ it('string input and number input are the same', async () => {
     y: 3,
   };
 
-  const solvedWitnessString = await new Noir(assert_lt_json).execute(inputsString);
-  const solvedWitnessNumber = await new Noir(assert_lt_json).execute(inputsNumber);
+  const solvedWitnessString = await new Noir(assert_lt_json).execute(inputsString, assert_lt_program);
+  const solvedWitnessNumber = await new Noir(assert_lt_json).execute(inputsNumber, assert_lt_program);
   chai.expect(solvedWitnessString).to.deep.equal(solvedWitnessNumber);
 });
 
@@ -48,7 +50,7 @@ it('0x prefixed string input for inputs will throw', async () => {
   };
 
   try {
-    await new Noir(assert_lt_json).execute(inputsHexPrefix);
+    await new Noir(assert_lt_json).execute(inputsHexPrefix, assert_lt_program);
     chai.expect.fail(
       'Expected generatedWitness to throw, due to inputs being prefixed with 0x. Currently not supported',
     );
@@ -66,7 +68,7 @@ describe('input validation', () => {
     };
 
     try {
-      await new Noir(assert_lt_json).execute(inputs);
+      await new Noir(assert_lt_json).execute(inputs, assert_lt_program);
       chai.expect.fail('Expected generatedWitness to throw, due to x not being convertible to a uint64');
     } catch (error) {
       const knownError = error;