chore: Switch Noir JS to use execute program instead of circuit

tooling/noir_js/scripts/compile_test_programs.sh

@@ -3,3 +3,5 @@
 rm -rf ./test/noir_compiled_examples/**/target
 nargo --program-dir ./test/noir_compiled_examples/assert_lt compile --force
 nargo --program-dir ./test/noir_compiled_examples/assert_msg_runtime compile --force
+nargo --program-dir ./test/noir_compiled_examples/fold_fibonacci compile --force
+

tooling/noir_js/src/program.ts

@@ -2,7 +2,7 @@
 import { Backend, CompiledCircuit, ProofData } from '@noir-lang/types';
 import { generateWitness } from './witness_generation.js';
 import initAbi, { abiDecode, InputMap, InputValue } from '@noir-lang/noirc_abi';
-import initACVM, { compressWitness, ForeignCallHandler } from '@noir-lang/acvm_js';
+import initACVM, { compressWitnessStack, ForeignCallHandler } from '@noir-lang/acvm_js';
 
 export class Noir {
   constructor(
@@ -55,9 +55,10 @@ export class Noir {
     foreignCallHandler?: ForeignCallHandler,
   ): Promise<{ witness: Uint8Array; returnValue: InputValue }> {
     await this.init();
-    const witness = await generateWitness(this.circuit, inputs, foreignCallHandler);
-    const { return_value: returnValue } = abiDecode(this.circuit.abi, witness);
-    return { witness: compressWitness(witness), returnValue };
+    const witness_stack = await generateWitness(this.circuit, inputs, foreignCallHandler);
+    const main_witness = witness_stack[0].witness;
+    const { return_value: returnValue } = abiDecode(this.circuit.abi, main_witness);
+    return { witness: compressWitnessStack(witness_stack), returnValue };
   }
 
   /**

tooling/noir_js/src/witness_generation.ts

@@ -1,12 +1,12 @@
 import { abiEncode, InputMap } from '@noir-lang/noirc_abi';
 import { base64Decode } from './base64_decode.js';
 import {
-  WitnessMap,
+  WitnessStack,
   ForeignCallHandler,
   ForeignCallInput,
   createBlackBoxSolver,
   WasmBlackBoxFunctionSolver,
-  executeCircuitWithBlackBoxSolver,
+  executeProgramWithBlackBoxSolver,
 } from '@noir-lang/acvm_js';
 import { CompiledCircuit } from '@noir-lang/types';
 
@@ -41,14 +41,14 @@ export async function generateWitness(
   compiledProgram: CompiledCircuit,
   inputs: InputMap,
   foreignCallHandler: ForeignCallHandler = defaultForeignCallHandler,
-): Promise<WitnessMap> {
+): Promise<WitnessStack> {
   // Throws on ABI encoding error
   const witnessMap = abiEncode(compiledProgram.abi, inputs);
 
   // Execute the circuit to generate the rest of the witnesses and serialize
   // them into a Uint8Array.
   try {
-    const solvedWitness = await executeCircuitWithBlackBoxSolver(
+    const solvedWitness = await executeProgramWithBlackBoxSolver(
       await getSolver(),
       base64Decode(compiledProgram.bytecode),
       witnessMap,

tooling/noir_js/test/node/e2e.test.ts

@@ -1,10 +1,12 @@
 import { expect } from 'chai';
 import assert_lt_json from '../noir_compiled_examples/assert_lt/target/assert_lt.json' assert { type: 'json' };
+import fold_fibonacci_json from '../noir_compiled_examples/fold_fibonacci/target/fold_fibonacci.json' assert { type: 'json' };
 import { Noir } from '@noir-lang/noir_js';
 import { BarretenbergBackend as Backend, BarretenbergVerifier as Verifier } from '@noir-lang/backend_barretenberg';
 import { CompiledCircuit } from '@noir-lang/types';
 
 const assert_lt_program = assert_lt_json as CompiledCircuit;
+const fold_fibonacci_program = fold_fibonacci_json as CompiledCircuit;
 
 it('end-to-end proof creation and verification (outer)', async () => {
   // Noir.Js part
@@ -149,3 +151,24 @@ it('[BUG] -- bb.js null function or function signature mismatch (outer-inner) ',
   const isValidInner = await prover.verifyProof(_proofInner);
   expect(isValidInner).to.be.true;
 });
+
+it('end-to-end proof creation and verification for multiple ACIR circuits (inner)', async () => {
+  // Noir.Js part
+  const inputs = {
+    x: '10',
+  };
+
+  const program = new Noir(fold_fibonacci_program);
+
+  const { witness } = await program.execute(inputs);
+
+  // bb.js part
+  //
+  // Proof creation
+  const backend = new Backend(fold_fibonacci_program);
+  const proof = await backend.generateProof(witness);
+
+  // Proof verification
+  const isValid = await backend.verifyProof(proof);
+  expect(isValid).to.be.true;
+});

tooling/noir_js/test/node/execute.test.ts

@@ -1,11 +1,13 @@
 import assert_lt_json from '../noir_compiled_examples/assert_lt/target/assert_lt.json' assert { type: 'json' };
 import assert_msg_json from '../noir_compiled_examples/assert_msg_runtime/target/assert_msg_runtime.json' assert { type: 'json' };
+import fold_fibonacci_json from '../noir_compiled_examples/fold_fibonacci/target/fold_fibonacci.json' assert { type: 'json' };
 import { Noir } from '@noir-lang/noir_js';
 import { CompiledCircuit } from '@noir-lang/types';
 import { expect } from 'chai';
 
 const assert_lt_program = assert_lt_json as CompiledCircuit;
 const assert_msg_runtime = assert_msg_json as CompiledCircuit;
+const fold_fibonacci_program = fold_fibonacci_json as CompiledCircuit;
 
 it('returns the return value of the circuit', async () => {
   const inputs = {
@@ -29,3 +31,15 @@ it('circuit with a dynamic assert message should fail on an assert failure not t
     expect(knownError.message).to.equal('Circuit execution failed: Error: Cannot satisfy constraint');
   }
 });
+
+it('successfully executes a program with multiple acir circuits', async () => {
+  const inputs = {
+    x: '10',
+  };
+  try {
+    await new Noir(fold_fibonacci_program).execute(inputs);
+  } catch (error) {
+    const knownError = error as Error;
+    expect(knownError.message).to.equal('Circuit execution failed: Error: Cannot satisfy constraint');
+  }
+});

tooling/noir_js/test/noir_compiled_examples/fold_fibonacci/Nargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "fold_fibonacci"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.28.0"
+
+[dependencies]

tooling/noir_js/test/noir_compiled_examples/fold_fibonacci/src/main.nr

@@ -0,0 +1,12 @@
+fn main(x: u32) {
+    assert(fibonacci(x) == 55);
+}
+
+#[fold]
+fn fibonacci(x: u32) -> u32 {
+    if x <= 1 {
+        x
+    } else {
+        fibonacci(x - 1) + fibonacci(x - 2)
+    }
+}