chore!: update to ACVM 0.13.0

Cargo.toml

@@ -50,3 +50,7 @@ toml = "0.7.2"
 url = "2.2.0"
 wasm-bindgen = { version = "0.2.83", features = ["serde-serialize"] }
 wasm-bindgen-test = "0.3.33"
+
+[patch.crates-io]
+acvm = { git = "https://github.com/noir-lang/acvm", rev = "3c6740af75125afc8ebb4379f781f8274015e2e2" }
+acvm-backend-barretenberg = { git = "https://github.com/noir-lang/acvm-backend-barretenberg", rev = "69cd578d0368c454010c7caf8fd4a00e69263e4a" }

crates/nargo/src/errors.rs

@@ -1,4 +1,4 @@
-use acvm::OpcodeResolutionError;
+use acvm::pwg::OpcodeResolutionError;
 use thiserror::Error;
 
 #[derive(Debug, Error)]

crates/nargo_cli/src/cli/mod.rs

@@ -129,7 +129,7 @@ mod tests {
         let mut driver = Driver::new(
             &acvm::Language::R1CS,
             #[allow(deprecated)]
-            Box::new(acvm::default_is_opcode_supported(acvm::Language::R1CS)),
+            Box::new(acvm::pwg::default_is_opcode_supported(acvm::Language::R1CS)),
         );
         driver.create_local_crate(&root_file, CrateType::Binary);
         crate::resolver::add_std_lib(&mut driver);

crates/noirc_driver/src/lib.rs

@@ -346,6 +346,6 @@ impl Driver {
 impl Default for Driver {
     fn default() -> Self {
         #[allow(deprecated)]
-        Self::new(&Language::R1CS, Box::new(acvm::default_is_opcode_supported(Language::R1CS)))
+        Self::new(&Language::R1CS, Box::new(acvm::pwg::default_is_opcode_supported(Language::R1CS)))
     }
 }

crates/noirc_driver/src/main.rs

@@ -9,7 +9,7 @@ fn main() {
     let mut driver = Driver::new(
         &Language::R1CS,
         #[allow(deprecated)]
-        Box::new(acvm::default_is_opcode_supported(Language::R1CS)),
+        Box::new(acvm::pwg::default_is_opcode_supported(Language::R1CS)),
     );
 
     // Add local crate to dep graph

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

@@ -92,7 +92,6 @@ pub(crate) fn evaluate(
                 }
                 BlackBoxFunc::SchnorrVerify
                 | BlackBoxFunc::EcdsaSecp256k1
-                | BlackBoxFunc::ComputeMerkleRoot
                 | BlackBoxFunc::HashToField128Security => {
                     prepare_outputs(&mut acir_gen.memory, instruction_id, 1, ctx, evaluator)
                 }
@@ -133,12 +132,6 @@ pub(crate) fn evaluate(
                     hashed_message: resolve_array(&args[3], acir_gen, ctx, evaluator),
                     output: outputs[0],
                 },
-                BlackBoxFunc::ComputeMerkleRoot => BlackBoxFuncCall::ComputeMerkleRoot {
-                    leaf: resolve_variable(&args[0], acir_gen, ctx, evaluator).unwrap(),
-                    index: resolve_variable(&args[1], acir_gen, ctx, evaluator).unwrap(),
-                    hash_path: resolve_array(&args[2], acir_gen, ctx, evaluator),
-                    output: outputs[0],
-                },
                 BlackBoxFunc::HashToField128Security => BlackBoxFuncCall::HashToField128Security {
                     inputs: resolve_array(&args[0], acir_gen, ctx, evaluator),
                     output: outputs[0],

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

@@ -115,8 +115,11 @@ fn permutation_layer(
 mod test {
     use acvm::{
         acir::{circuit::opcodes::FunctionInput, native_types::Witness, native_types::WitnessMap},
-        pwg::{block::Blocks, solve, OpcodeResolution, PartialWitnessGeneratorStatus},
-        FieldElement, OpcodeResolutionError, PartialWitnessGenerator,
+        pwg::{
+            block::Blocks, solve, OpcodeResolution, OpcodeResolutionError,
+            PartialWitnessGeneratorStatus,
+        },
+        FieldElement, PartialWitnessGenerator,
     };
 
     use crate::{
@@ -135,57 +138,6 @@ mod test {
         ) -> Result<OpcodeResolution, OpcodeResolutionError> {
             panic!("Path not trodden by this test")
         }
-        fn and(
-            &self,
-            _initial_witness: &mut WitnessMap,
-            _lhs: &FunctionInput,
-            _rhs: &FunctionInput,
-            _output: &Witness,
-        ) -> Result<OpcodeResolution, OpcodeResolutionError> {
-            panic!("Path not trodden by this test")
-        }
-        fn xor(
-            &self,
-            _initial_witness: &mut WitnessMap,
-            _lhs: &FunctionInput,
-            _rhs: &FunctionInput,
-            _output: &Witness,
-        ) -> Result<OpcodeResolution, OpcodeResolutionError> {
-            panic!("Path not trodden by this test")
-        }
-        fn range(
-            &self,
-            _initial_witness: &mut WitnessMap,
-            _input: &FunctionInput,
-        ) -> Result<OpcodeResolution, OpcodeResolutionError> {
-            panic!("Path not trodden by this test")
-        }
-        fn sha256(
-            &self,
-            _initial_witness: &mut WitnessMap,
-            _inputs: &[FunctionInput],
-            _outputs: &[Witness],
-        ) -> Result<OpcodeResolution, OpcodeResolutionError> {
-            panic!("Path not trodden by this test")
-        }
-        fn blake2s(
-            &self,
-            _initial_witness: &mut WitnessMap,
-            _inputs: &[FunctionInput],
-            _outputs: &[Witness],
-        ) -> Result<OpcodeResolution, OpcodeResolutionError> {
-            panic!("Path not trodden by this test")
-        }
-        fn compute_merkle_root(
-            &self,
-            _initial_witness: &mut WitnessMap,
-            _leaf: &FunctionInput,
-            _index: &FunctionInput,
-            _hash_path: &[FunctionInput],
-            _output: &Witness,
-        ) -> Result<OpcodeResolution, OpcodeResolutionError> {
-            panic!("Path not trodden by this test")
-        }
         fn schnorr_verify(
             &self,
             _initial_witness: &mut WitnessMap,
@@ -205,25 +157,6 @@ mod test {
         ) -> Result<OpcodeResolution, OpcodeResolutionError> {
             panic!("Path not trodden by this test")
         }
-        fn hash_to_field_128_security(
-            &self,
-            _initial_witness: &mut WitnessMap,
-            _inputs: &[FunctionInput],
-            _output: &Witness,
-        ) -> Result<OpcodeResolution, OpcodeResolutionError> {
-            panic!("Path not trodden by this test")
-        }
-        fn ecdsa_secp256k1(
-            &self,
-            _initial_witness: &mut WitnessMap,
-            _public_key_x: &[FunctionInput],
-            _public_key_y: &[FunctionInput],
-            _signature: &[FunctionInput],
-            _message: &[FunctionInput],
-            _output: &Witness,
-        ) -> Result<OpcodeResolution, OpcodeResolutionError> {
-            panic!("Path not trodden by this test")
-        }
         fn fixed_base_scalar_mul(
             &self,
             _initial_witness: &mut WitnessMap,
@@ -232,14 +165,6 @@ mod test {
         ) -> Result<OpcodeResolution, OpcodeResolutionError> {
             panic!("Path not trodden by this test")
         }
-        fn keccak256(
-            &self,
-            _initial_witness: &mut WitnessMap,
-            _inputs: &[FunctionInput],
-            _outputs: &[Witness],
-        ) -> Result<OpcodeResolution, OpcodeResolutionError> {
-            panic!("Path not trodden by this test")
-        }
     }
 
     // Check that a random network constrains its output to be a permutation of any random input

crates/noirc_evaluator/src/ssa/builtin.rs

@@ -79,9 +79,7 @@ impl Opcode {
                     | BlackBoxFunc::FixedBaseScalarMul => BigUint::zero(),
                     // Verify returns zero or one
                     BlackBoxFunc::SchnorrVerify | BlackBoxFunc::EcdsaSecp256k1 => BigUint::one(),
-                    BlackBoxFunc::ComputeMerkleRoot | BlackBoxFunc::HashToField128Security => {
-                        ObjectType::native_field().max_size()
-                    }
+                    BlackBoxFunc::HashToField128Security => ObjectType::native_field().max_size(),
                     BlackBoxFunc::AES => {
                         todo!("ICE: AES is unimplemented")
                     }
@@ -106,9 +104,7 @@ impl Opcode {
                     BlackBoxFunc::SHA256 | BlackBoxFunc::Blake2s | BlackBoxFunc::Keccak256 => {
                         (32, ObjectType::unsigned_integer(8))
                     }
-                    BlackBoxFunc::ComputeMerkleRoot | BlackBoxFunc::HashToField128Security => {
-                        (1, ObjectType::native_field())
-                    }
+                    BlackBoxFunc::HashToField128Security => (1, ObjectType::native_field()),
                     // See issue #775 on changing this to return a boolean
                     BlackBoxFunc::SchnorrVerify | BlackBoxFunc::EcdsaSecp256k1 => {
                         (1, ObjectType::native_field())

crates/wasm/src/compile.rs

@@ -79,7 +79,7 @@ pub fn compile(args: JsValue) -> JsValue {
     let mut driver = noirc_driver::Driver::new(
         &language,
         #[allow(deprecated)]
-        Box::new(acvm::default_is_opcode_supported(language.clone())),
+        Box::new(acvm::pwg::default_is_opcode_supported(language.clone())),
     );
 
     let path = PathBuf::from(&options.entry_point);

noir_stdlib/src/merkle.nr

@@ -18,4 +18,4 @@ fn compute_merkle_root(leaf: Field, index: Field, hash_path: [Field]) -> Field {
       current = crate::hash::pedersen([hash_left, hash_right])[0];
     };
     current
-}
+}