Merge branch 'master' into feat/4824-multiple-acir-calls

.aztec-sync-commit

@@ -1 +1 @@
-12af650f0d27c37dca06bb329bf76a5574534d78
+ed815a3713fc311056a8bd0a616945f12d9be2a8

Cargo.toml

@@ -24,6 +24,7 @@ members = [
     "tooling/noirc_abi",
     "tooling/noirc_abi_wasm",
     "tooling/acvm_cli",
+    "tooling/profiler",
     # ACVM
     "acvm-repo/acir_field",
     "acvm-repo/acir",
@@ -36,7 +37,7 @@ members = [
     # Utility crates
     "utils/iter-extended",
 ]
-default-members = ["tooling/nargo_cli", "tooling/acvm_cli"]
+default-members = ["tooling/nargo_cli", "tooling/acvm_cli", "tooling/profiler"]
 resolver = "2"
 
 [workspace.package]
@@ -84,7 +85,7 @@ acvm_cli = { path = "tooling/acvm_cli" }
 # Arkworks
 ark-bn254 = { version = "^0.4.0", default-features = false, features = ["curve"] }
 ark-bls12-381 = { version = "^0.4.0", default-features = false, features = ["curve"] }
-grumpkin = { version = "0.1.0", package = "noir_grumpkin", features = ["std"] } 
+grumpkin = { version = "0.1.0", package = "noir_grumpkin", features = ["std"] }
 ark-ec = { version = "^0.4.0", default-features = false }
 ark-ff = { version = "^0.4.0", default-features = false }
 ark-std = { version = "^0.4.0", default-features = false }
@@ -143,11 +144,11 @@ similar-asserts = "1.5.0"
 tempfile = "3.6.0"
 jsonrpc = { version = "0.16.0", features = ["minreq_http"] }
 flate2 = "1.0.24"
+color-eyre = "0.6.2"
 rand = "0.8.5"
 proptest = "1.2.0"
 proptest-derive = "0.4.0"
 
-
 im = { version = "15.1", features = ["serde"] }
 tracing = "0.1.40"
 tracing-web = "0.1.3"

acvm-repo/acir/src/circuit/black_box_functions.rs

@@ -82,9 +82,9 @@ pub enum BlackBoxFunc {
     ///
     /// [grumpkin]: https://hackmd.io/@aztec-network/ByzgNxBfd#2-Grumpkin---A-curve-on-top-of-BN-254-for-SNARK-efficient-group-operations
     SchnorrVerify,
-    /// Deprecated. To be removed with a sync from aztec-packages
+    /// Will be deprecated
     PedersenCommitment,
-    /// Deprecated. To be removed with a sync from aztec-packages
+    /// Will be deprecated
     PedersenHash,
     /// Verifies a ECDSA signature over the secp256k1 curve.
     /// - inputs:
@@ -227,8 +227,8 @@ impl BlackBoxFunc {
             BlackBoxFunc::BigIntToLeBytes => "bigint_to_le_bytes",
             BlackBoxFunc::Poseidon2Permutation => "poseidon2_permutation",
             BlackBoxFunc::Sha256Compression => "sha256_compression",
-            BlackBoxFunc::PedersenCommitment => "deprecated pedersen commitment",
-            BlackBoxFunc::PedersenHash => "deprecated pedersen hash",
+            BlackBoxFunc::PedersenCommitment => "pedersen_commitment",
+            BlackBoxFunc::PedersenHash => "pedersen_hash",
         }
     }
 
@@ -257,8 +257,8 @@ impl BlackBoxFunc {
             "bigint_to_le_bytes" => Some(BlackBoxFunc::BigIntToLeBytes),
             "poseidon2_permutation" => Some(BlackBoxFunc::Poseidon2Permutation),
             "sha256_compression" => Some(BlackBoxFunc::Sha256Compression),
-            "deprecated pedersen commitment" => Some(BlackBoxFunc::PedersenCommitment),
-            "deprecated pedersen hash" => Some(BlackBoxFunc::PedersenHash),
+            "pedersen_commitment" => Some(BlackBoxFunc::PedersenCommitment),
+            "pedersen_hash" => Some(BlackBoxFunc::PedersenHash),
             _ => None,
         }
     }

acvm-repo/acir/src/circuit/opcodes/black_box_function_call.rs

@@ -54,13 +54,13 @@ pub enum BlackBoxFuncCall {
         message: Vec<FunctionInput>,
         output: Witness,
     },
-    /// Deprecated. To be removed with a sync from aztec-packages
+    /// Will be deprecated
     PedersenCommitment {
         inputs: Vec<FunctionInput>,
         domain_separator: u32,
         outputs: (Witness, Witness),
     },
-    /// Deprecated. To be removed with a sync from aztec-packages
+    /// Will be deprecated
     PedersenHash {
         inputs: Vec<FunctionInput>,
         domain_separator: u32,
@@ -222,6 +222,8 @@ impl BlackBoxFuncCall {
             | BlackBoxFuncCall::Blake2s { inputs, .. }
             | BlackBoxFuncCall::Blake3 { inputs, .. }
             | BlackBoxFuncCall::BigIntFromLeBytes { inputs, .. }
+            | BlackBoxFuncCall::PedersenCommitment { inputs, .. }
+            | BlackBoxFuncCall::PedersenHash { inputs, .. }
             | BlackBoxFuncCall::Poseidon2Permutation { inputs, .. } => inputs.to_vec(),
 
             BlackBoxFuncCall::Keccakf1600 { inputs, .. } => inputs.to_vec(),
@@ -318,8 +320,6 @@ impl BlackBoxFuncCall {
                 inputs.push(*key_hash);
                 inputs
             }
-            BlackBoxFuncCall::PedersenCommitment { .. } => todo!(),
-            BlackBoxFuncCall::PedersenHash { .. } => todo!(),
         }
     }
 
@@ -341,7 +341,9 @@ impl BlackBoxFuncCall {
             | BlackBoxFuncCall::XOR { output, .. }
             | BlackBoxFuncCall::SchnorrVerify { output, .. }
             | BlackBoxFuncCall::EcdsaSecp256k1 { output, .. }
+            | BlackBoxFuncCall::PedersenHash { output, .. }
             | BlackBoxFuncCall::EcdsaSecp256r1 { output, .. } => vec![*output],
+            BlackBoxFuncCall::PedersenCommitment { outputs, .. } => vec![outputs.0, outputs.1],
             BlackBoxFuncCall::MultiScalarMul { outputs, .. }
             | BlackBoxFuncCall::EmbeddedCurveAdd { outputs, .. } => {
                 vec![outputs.0, outputs.1, outputs.2]
@@ -356,8 +358,6 @@ impl BlackBoxFuncCall {
                 vec![]
             }
             BlackBoxFuncCall::BigIntToLeBytes { outputs, .. } => outputs.to_vec(),
-            BlackBoxFuncCall::PedersenCommitment { .. } => todo!(),
-            BlackBoxFuncCall::PedersenHash { .. } => todo!(),
         }
     }
 }

acvm-repo/acvm/src/pwg/blackbox/mod.rs

@@ -18,6 +18,7 @@ pub(crate) mod bigint;
 mod embedded_curve_ops;
 mod hash;
 mod logic;
+mod pedersen;
 mod range;
 mod signature;
 pub(crate) mod utils;
@@ -26,6 +27,7 @@ use embedded_curve_ops::{embedded_curve_add, multi_scalar_mul};
 // Hash functions should eventually be exposed for external consumers.
 use hash::{solve_generic_256_hash_opcode, solve_sha_256_permutation_opcode};
 use logic::{and, xor};
+use pedersen::{pedersen, pedersen_hash};
 pub(crate) use range::solve_range_opcode;
 use signature::{
     ecdsa::{secp256k1_prehashed, secp256r1_prehashed},
@@ -125,6 +127,12 @@ pub(crate) fn solve<F: AcirField>(
             message,
             *output,
         ),
+        BlackBoxFuncCall::PedersenCommitment { inputs, domain_separator, outputs } => {
+            pedersen(backend, initial_witness, inputs, *domain_separator, *outputs)
+        }
+        BlackBoxFuncCall::PedersenHash { inputs, domain_separator, output } => {
+            pedersen_hash(backend, initial_witness, inputs, *domain_separator, *output)
+        }
         BlackBoxFuncCall::EcdsaSecp256k1 {
             public_key_x,
             public_key_y,
@@ -179,7 +187,5 @@ pub(crate) fn solve<F: AcirField>(
         BlackBoxFuncCall::Poseidon2Permutation { inputs, outputs, len } => {
             solve_poseidon2_permutation_opcode(backend, initial_witness, inputs, outputs, *len)
         }
-        BlackBoxFuncCall::PedersenCommitment { .. } => todo!("Deprecated BlackBox"),
-        BlackBoxFuncCall::PedersenHash { .. } => todo!("Deprecated BlackBox"),
     }
 }

acvm-repo/acvm/src/pwg/blackbox/pedersen.rs

@@ -0,0 +1,47 @@
+use acir::{
+    circuit::opcodes::FunctionInput,
+    native_types::{Witness, WitnessMap},
+    AcirField,
+};
+
+use crate::{
+    pwg::{insert_value, witness_to_value, OpcodeResolutionError},
+    BlackBoxFunctionSolver,
+};
+
+pub(super) fn pedersen<F: AcirField>(
+    backend: &impl BlackBoxFunctionSolver<F>,
+    initial_witness: &mut WitnessMap<F>,
+    inputs: &[FunctionInput],
+    domain_separator: u32,
+    outputs: (Witness, Witness),
+) -> Result<(), OpcodeResolutionError<F>> {
+    let scalars: Result<Vec<_>, _> =
+        inputs.iter().map(|input| witness_to_value(initial_witness, input.witness)).collect();
+    let scalars: Vec<_> = scalars?.into_iter().cloned().collect();
+
+    let (res_x, res_y) = backend.pedersen_commitment(&scalars, domain_separator)?;
+
+    insert_value(&outputs.0, res_x, initial_witness)?;
+    insert_value(&outputs.1, res_y, initial_witness)?;
+
+    Ok(())
+}
+
+pub(super) fn pedersen_hash<F: AcirField>(
+    backend: &impl BlackBoxFunctionSolver<F>,
+    initial_witness: &mut WitnessMap<F>,
+    inputs: &[FunctionInput],
+    domain_separator: u32,
+    output: Witness,
+) -> Result<(), OpcodeResolutionError<F>> {
+    let scalars: Result<Vec<_>, _> =
+        inputs.iter().map(|input| witness_to_value(initial_witness, input.witness)).collect();
+    let scalars: Vec<_> = scalars?.into_iter().cloned().collect();
+
+    let res = backend.pedersen_hash(&scalars, domain_separator)?;
+
+    insert_value(&output, res, initial_witness)?;
+
+    Ok(())
+}

acvm-repo/blackbox_solver/src/curve_specific_solver.rs

@@ -14,6 +14,16 @@ pub trait BlackBoxFunctionSolver<F> {
         signature: &[u8; 64],
         message: &[u8],
     ) -> Result<bool, BlackBoxResolutionError>;
+    fn pedersen_commitment(
+        &self,
+        inputs: &[F],
+        domain_separator: u32,
+    ) -> Result<(F, F), BlackBoxResolutionError>;
+    fn pedersen_hash(
+        &self,
+        inputs: &[F],
+        domain_separator: u32,
+    ) -> Result<F, BlackBoxResolutionError>;
     fn multi_scalar_mul(
         &self,
         points: &[F],
@@ -57,6 +67,21 @@ impl<F> BlackBoxFunctionSolver<F> for StubbedBlackBoxSolver {
     ) -> Result<bool, BlackBoxResolutionError> {
         Err(Self::fail(BlackBoxFunc::SchnorrVerify))
     }
+    fn pedersen_commitment(
+        &self,
+        _inputs: &[F],
+        _domain_separator: u32,
+    ) -> Result<(F, F), BlackBoxResolutionError> {
+        Err(Self::fail(BlackBoxFunc::PedersenCommitment))
+    }
+    fn pedersen_hash(
+        &self,
+        _inputs: &[F],
+        _domain_separator: u32,
+    ) -> Result<F, BlackBoxResolutionError> {
+        Err(Self::fail(BlackBoxFunc::PedersenHash))
+    }
+
     fn multi_scalar_mul(
         &self,
         _points: &[F],

acvm-repo/bn254_blackbox_solver/src/lib.rs

@@ -10,6 +10,7 @@ mod pedersen;
 mod poseidon2;
 mod schnorr;
 
+use ark_ec::AffineRepr;
 pub use embedded_curve_ops::{embedded_curve_add, multi_scalar_mul};
 pub use generator::generators::derive_generators;
 pub use poseidon2::poseidon2_permutation;
@@ -40,6 +41,33 @@ impl BlackBoxFunctionSolver<FieldElement> for Bn254BlackBoxSolver {
         ))
     }
 
+    fn pedersen_commitment(
+        &self,
+        inputs: &[FieldElement],
+        domain_separator: u32,
+    ) -> Result<(FieldElement, FieldElement), BlackBoxResolutionError> {
+        let inputs: Vec<grumpkin::Fq> = inputs.iter().map(|input| input.into_repr()).collect();
+        let result = pedersen::commitment::commit_native_with_index(&inputs, domain_separator);
+        let result = if let Some((x, y)) = result.xy() {
+            (FieldElement::from_repr(*x), FieldElement::from_repr(*y))
+        } else {
+            (FieldElement::from(0_u128), FieldElement::from(0_u128))
+        };
+
+        Ok(result)
+    }
+
+    fn pedersen_hash(
+        &self,
+        inputs: &[FieldElement],
+        domain_separator: u32,
+    ) -> Result<FieldElement, BlackBoxResolutionError> {
+        let inputs: Vec<grumpkin::Fq> = inputs.iter().map(|input| input.into_repr()).collect();
+        let result = pedersen::hash::hash_with_index(&inputs, domain_separator);
+        let result = FieldElement::from_repr(result);
+        Ok(result)
+    }
+
     fn multi_scalar_mul(
         &self,
         points: &[FieldElement],