feat!: update to ACVM 0.16.0

Cargo.toml

@@ -24,7 +24,7 @@ edition = "2021"
 rust-version = "1.66"
 
 [workspace.dependencies]
-acvm = "0.15.1"
+acvm = "0.16.0"
 arena = { path = "crates/arena" }
 fm = { path = "crates/fm" }
 iter-extended = { path = "crates/iter-extended" }

crates/nargo/src/ops/execute.rs

@@ -1,64 +1,62 @@
-use acvm::acir::circuit::Opcode;
-use acvm::pwg::{solve, Blocks, PartialWitnessGeneratorStatus, UnresolvedBrilligCall};
-use acvm::PartialWitnessGenerator;
+use acvm::acir::brillig_vm::ForeignCallResult;
+use acvm::pwg::{ACVMStatus, ForeignCallWaitInfo, ACVM};
+use acvm::BlackBoxFunctionSolver;
 use acvm::{acir::circuit::Circuit, acir::native_types::WitnessMap};
 
 use crate::NargoError;
 
-pub fn execute_circuit(
-    backend: &impl PartialWitnessGenerator,
+pub fn execute_circuit<B: BlackBoxFunctionSolver + Default>(
+    _backend: &B,
     circuit: Circuit,
-    mut initial_witness: WitnessMap,
+    initial_witness: WitnessMap,
 ) -> Result<WitnessMap, NargoError> {
-    let mut blocks = Blocks::default();
-    let solver_status = solve(backend, &mut initial_witness, &mut blocks, circuit.opcodes)?;
+    let mut acvm = ACVM::new(B::default(), circuit.opcodes, initial_witness);
 
-    // TODO(#1615): Nargo only supports "oracle_print_**_impl" functions  that print a singular value or an array and nothing else
-    // This should be expanded in a general logging refactor
-    if let PartialWitnessGeneratorStatus::RequiresOracleData {
-        unresolved_brillig_calls,
-        required_oracle_data,
-        unsolved_opcodes,
-    } = solver_status
-    {
-        if !required_oracle_data.is_empty() {
-            unreachable!("oracles are not supported by nargo execute")
-        }
-        for unresolved_brillig_call in unresolved_brillig_calls {
-            let UnresolvedBrilligCall { foreign_call_wait_info, mut brillig } =
-                unresolved_brillig_call;
+    loop {
+        let solver_status = acvm.solve();
 
-            // Execute foreign calls
-            // TODO(#1615): "oracle_print_impl" and "oracle_print_array_impl" are just identity funcs
-            if foreign_call_wait_info.function == "oracle_print_impl" {
-                let values = &foreign_call_wait_info.inputs[0];
-                println!("{:?}", values[0].to_field().to_hex());
-                brillig.foreign_call_results.push(foreign_call_wait_info.inputs[0][0].into());
-            } else if foreign_call_wait_info.function == "oracle_print_array_impl" {
-                let mut outputs_hex = Vec::new();
-                for values in foreign_call_wait_info.inputs.clone() {
-                    for value in values {
-                        outputs_hex.push(value.to_field().to_hex());
-                    }
+        match solver_status {
+            ACVMStatus::Solved => break,
+            ACVMStatus::InProgress => {
+                unreachable!("Execution should not stop while in `InProgress` state.")
+            }
+            ACVMStatus::Failure(error) => return Err(error.into()),
+            ACVMStatus::RequiresForeignCall => {
+                while let Some(foreign_call) = acvm.get_pending_foreign_call() {
+                    let foreign_call_result = execute_foreign_call(foreign_call);
+                    acvm.resolve_pending_foreign_call(foreign_call_result);
                 }
-                // Join all of the hex strings using a comma
-                let comma_separated_elements = outputs_hex.join(", ");
-                let output_witnesses_string = "[".to_owned() + &comma_separated_elements + "]";
-                println!("{output_witnesses_string}");
-                brillig.foreign_call_results.push(foreign_call_wait_info.inputs[0][0].into());
             }
+        }
+    }
 
-            let mut next_opcodes_for_solving = vec![Opcode::Brillig(brillig)];
-            next_opcodes_for_solving.extend_from_slice(&unsolved_opcodes[..]);
+    let solved_witness = acvm.finalize();
+    Ok(solved_witness)
+}
 
-            let solver_status =
-                solve(backend, &mut initial_witness, &mut blocks, next_opcodes_for_solving)?;
-            if matches!(solver_status, PartialWitnessGeneratorStatus::RequiresOracleData { .. }) {
-                todo!("Add multiple foreign call support to nargo execute")
-                // TODO 1557
+fn execute_foreign_call(foreign_call: &ForeignCallWaitInfo) -> ForeignCallResult {
+    // TODO(#1615): Nargo only supports "oracle_print_**_impl" functions  that print a singular value or an array and nothing else
+    // This should be expanded in a general logging refactor
+    match foreign_call.function.as_str() {
+        "oracle_print_impl" => {
+            let values = &foreign_call.inputs[0];
+            println!("{:?}", values[0].to_field().to_hex());
+            values[0].into()
+        }
+        "oracle_print_array_impl" => {
+            let mut outputs_hex = Vec::new();
+            for values in &foreign_call.inputs {
+                for value in values {
+                    outputs_hex.push(value.to_field().to_hex());
+                }
             }
+            // Join all of the hex strings using a comma
+            let comma_separated_elements = outputs_hex.join(", ");
+            let output_witnesses_string = "[".to_owned() + &comma_separated_elements + "]";
+            println!("{output_witnesses_string}");
+
+            foreign_call.inputs[0][0].into()
         }
+        _ => panic!("unexpected foreign call type"),
     }
-
-    Ok(initial_witness)
 }

crates/nargo_cli/Cargo.toml

@@ -43,7 +43,7 @@ color-eyre = "0.6.2"
 tokio = { version = "1.0", features = ["io-std"] }
 
 # Backends
-acvm-backend-barretenberg = { version = "0.5.1", default-features = false }
+acvm-backend-barretenberg = { version = "0.6.0", default-features = false }
 
 [dev-dependencies]
 tempdir = "0.3.7"

crates/noirc_driver/src/lib.rs

@@ -248,13 +248,7 @@ impl Driver {
         let mut errors = warnings;
 
         for contract in contracts {
-            match self.compile_contract(
-                contract,
-                // TODO: Remove clone when it implements Copy
-                np_language.clone(),
-                is_opcode_supported,
-                options,
-            ) {
+            match self.compile_contract(contract, np_language, is_opcode_supported, options) {
                 Ok(contract) => compiled_contracts.push(contract),
                 Err(mut more_errors) => errors.append(&mut more_errors),
             }
@@ -303,8 +297,7 @@ impl Driver {
             let function = match self.compile_no_check(
                 options,
                 *function_id,
-                // TODO: Remove clone when it implements Copy
-                np_language.clone(),
+                np_language,
                 is_opcode_supported,
             ) {
                 Ok(function) => function,

crates/noirc_evaluator/src/brillig/brillig_gen/brillig_block.rs

@@ -10,7 +10,9 @@ use crate::ssa_refactor::ir::{
     types::{NumericType, Type},
     value::{Value, ValueId},
 };
-use acvm::acir::brillig_vm::{BinaryFieldOp, BinaryIntOp, RegisterIndex, RegisterOrMemory};
+use acvm::acir::brillig_vm::{
+    BinaryFieldOp, BinaryIntOp, HeapArray, RegisterIndex, RegisterOrMemory,
+};
 use acvm::FieldElement;
 use iter_extended::vecmap;
 
@@ -440,7 +442,9 @@ impl<'block> BrilligBlock<'block> {
         let typ = dfg[value_id].get_type();
         match typ {
             Type::Numeric(_) => RegisterOrMemory::RegisterIndex(register_index),
-            Type::Array(_, size) => RegisterOrMemory::HeapArray(register_index, size),
+            Type::Array(_, size) => {
+                RegisterOrMemory::HeapArray(HeapArray { pointer: register_index, size })
+            }
             _ => {
                 unreachable!("type not supported for conversion into brillig register")
             }

crates/noirc_evaluator/src/brillig/brillig_ir.rs

@@ -714,8 +714,8 @@ mod tests {
     use std::vec;
 
     use acvm::acir::brillig_vm::{
-        BinaryIntOp, ForeignCallOutput, ForeignCallResult, RegisterIndex, RegisterOrMemory,
-        Registers, VMStatus, Value, VM,
+        BinaryIntOp, ForeignCallOutput, ForeignCallResult, HeapVector, RegisterIndex,
+        RegisterOrMemory, Registers, VMStatus, Value, VM,
     };
 
     use crate::brillig::brillig_ir::{BrilligContext, BRILLIG_MEMORY_ADDRESSING_BIT_SIZE};
@@ -749,7 +749,7 @@ mod tests {
         context.foreign_call_instruction(
             "make_number_sequence".into(),
             &[RegisterOrMemory::RegisterIndex(r_input_size)],
-            &[RegisterOrMemory::HeapVector(r_stack, r_output_size)],
+            &[RegisterOrMemory::HeapVector(HeapVector { pointer: r_stack, size: r_output_size })],
         );
         // push stack frame by r_returned_size
         context.binary_instruction(

crates/noirc_evaluator/src/brillig/brillig_ir/debug_show.rs

@@ -1,7 +1,9 @@
 ///! This module contains functions for producing a higher level view disassembler of Brillig.
 use super::BrilligBinaryOp;
 use crate::brillig::brillig_ir::{ReservedRegisters, BRILLIG_MEMORY_ADDRESSING_BIT_SIZE};
-use acvm::acir::brillig_vm::{BinaryFieldOp, BinaryIntOp, RegisterIndex, RegisterOrMemory, Value};
+use acvm::acir::brillig_vm::{
+    BinaryFieldOp, BinaryIntOp, HeapArray, HeapVector, RegisterIndex, RegisterOrMemory, Value,
+};
 
 /// Controls whether debug traces are enabled
 const ENABLE_DEBUG_TRACE: bool = true;
@@ -100,11 +102,11 @@ impl DebugToString for RegisterOrMemory {
     fn debug_to_string(&self) -> String {
         match self {
             RegisterOrMemory::RegisterIndex(index) => index.debug_to_string(),
-            RegisterOrMemory::HeapArray(index, size) => {
-                format!("{}[0..{}]", index.debug_to_string(), size)
+            RegisterOrMemory::HeapArray(HeapArray { pointer, size }) => {
+                format!("{}[0..{}]", pointer.debug_to_string(), size)
             }
-            RegisterOrMemory::HeapVector(index, size_register) => {
-                format!("{}[0..*{}]", index.debug_to_string(), size_register.debug_to_string())
+            RegisterOrMemory::HeapVector(HeapVector { pointer, size }) => {
+                format!("{}[0..*{}]", pointer.debug_to_string(), size.debug_to_string())
             }
         }
     }

crates/noirc_evaluator/src/ssa/acir_gen/operations/intrinsics.rs

@@ -130,13 +130,13 @@ pub(crate) fn evaluate(
                         ctx.get_as_constant(args[1]).expect("domain separator to be comptime");
                     BlackBoxFuncCall::Pedersen {
                         inputs: resolve_array(&args[0], acir_gen, ctx, evaluator),
-                        outputs: outputs.to_vec(),
+                        outputs: (outputs[0], outputs[1]),
                         domain_separator: separator.to_u128() as u32,
                     }
                 }
                 BlackBoxFunc::FixedBaseScalarMul => BlackBoxFuncCall::FixedBaseScalarMul {
                     input: resolve_variable(&args[0], acir_gen, ctx, evaluator).unwrap(),
-                    outputs: outputs.to_vec(),
+                    outputs: (outputs[0], outputs[1]),
                 },
                 BlackBoxFunc::SchnorrVerify => BlackBoxFuncCall::SchnorrVerify {
                     public_key_x: resolve_variable(&args[0], acir_gen, ctx, evaluator).unwrap(),