feat: remove unnecessary mutation of blackbox functions during flattening

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

@@ -12,6 +12,7 @@ pub(super) fn multi_scalar_mul<F: AcirField>(
     initial_witness: &mut WitnessMap<F>,
     points: &[FunctionInput<F>],
     scalars: &[FunctionInput<F>],
+    predicate: FunctionInput<F>,
     outputs: (Witness, Witness, Witness),
 ) -> Result<(), OpcodeResolutionError<F>> {
     let points: Result<Vec<_>, _> =
@@ -20,6 +21,9 @@ pub(super) fn multi_scalar_mul<F: AcirField>(
 
     let scalars: Result<Vec<_>, _> =
         scalars.iter().map(|input| input_to_value(initial_witness, *input)).collect();
+
+    let predicate = input_to_value(initial_witness, predicate)?.is_one();
+
     let mut scalars_lo = Vec::new();
     let mut scalars_hi = Vec::new();
     for (i, scalar) in scalars?.into_iter().enumerate() {
@@ -31,7 +35,7 @@ pub(super) fn multi_scalar_mul<F: AcirField>(
     }
     // Call the backend's multi-scalar multiplication function
     let (res_x, res_y, is_infinite) =
-        backend.multi_scalar_mul(&points, &scalars_lo, &scalars_hi)?;
+        backend.multi_scalar_mul(&points, &scalars_lo, &scalars_hi, predicate)?;
 
     // Insert the resulting point into the witness map
     insert_value(&outputs.0, res_x, initial_witness)?;
@@ -45,6 +49,7 @@ pub(super) fn embedded_curve_add<F: AcirField>(
     initial_witness: &mut WitnessMap<F>,
     input1: [FunctionInput<F>; 3],
     input2: [FunctionInput<F>; 3],
+    predicate: FunctionInput<F>,
     outputs: (Witness, Witness, Witness),
 ) -> Result<(), OpcodeResolutionError<F>> {
     let input1_x = input_to_value(initial_witness, input1[0])?;
@@ -53,13 +58,15 @@ pub(super) fn embedded_curve_add<F: AcirField>(
     let input2_x = input_to_value(initial_witness, input2[0])?;
     let input2_y = input_to_value(initial_witness, input2[1])?;
     let input2_infinite = input_to_value(initial_witness, input2[2])?;
+    let predicate = input_to_value(initial_witness, predicate)?.is_one();
     let (res_x, res_y, res_infinite) = backend.ec_add(
         &input1_x,
         &input1_y,
         &input1_infinite,
         &input2_x,
         &input2_y,
         &input2_infinite,
+        predicate,
     )?;
 
     insert_value(&outputs.0, res_x, initial_witness)?;

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

@@ -116,13 +116,14 @@ pub(crate) fn solve<F: AcirField>(
             signature,
             hashed_message: message,
             output,
-            ..
+            predicate,
         } => secp256k1_prehashed(
             initial_witness,
             public_key_x,
             public_key_y,
             signature,
             message.as_ref(),
+            predicate,
             *output,
         ),
         BlackBoxFuncCall::EcdsaSecp256r1 {
@@ -131,20 +132,21 @@ pub(crate) fn solve<F: AcirField>(
             signature,
             hashed_message: message,
             output,
-            ..
+            predicate,
         } => secp256r1_prehashed(
             initial_witness,
             public_key_x,
             public_key_y,
             signature,
             message.as_ref(),
+            predicate,
             *output,
         ),
-        BlackBoxFuncCall::MultiScalarMul { points, scalars, outputs, .. } => {
-            multi_scalar_mul(backend, initial_witness, points, scalars, *outputs)
+        BlackBoxFuncCall::MultiScalarMul { points, scalars, outputs, predicate } => {
+            multi_scalar_mul(backend, initial_witness, points, scalars, *predicate, *outputs)
         }
-        BlackBoxFuncCall::EmbeddedCurveAdd { input1, input2, outputs, .. } => {
-            embedded_curve_add(backend, initial_witness, **input1, **input2, *outputs)
+        BlackBoxFuncCall::EmbeddedCurveAdd { input1, input2, outputs, predicate } => {
+            embedded_curve_add(backend, initial_witness, **input1, **input2, *predicate, *outputs)
         }
         // Recursive aggregation will be entirely handled by the backend and is not solved by the ACVM
         BlackBoxFuncCall::RecursiveAggregation { .. } => Ok(()),

acvm-repo/acvm/src/pwg/blackbox/signature/ecdsa.rs

@@ -7,7 +7,7 @@ use acvm_blackbox_solver::{ecdsa_secp256k1_verify, ecdsa_secp256r1_verify};
 
 use crate::{
     OpcodeResolutionError,
-    pwg::{blackbox::utils::to_u8_array, insert_value},
+    pwg::{blackbox::utils::to_u8_array, input_to_value, insert_value},
 };
 
 pub(crate) fn secp256k1_prehashed<F: AcirField>(
@@ -16,14 +16,19 @@ pub(crate) fn secp256k1_prehashed<F: AcirField>(
     public_key_y_inputs: &[FunctionInput<F>; 32],
     signature_inputs: &[FunctionInput<F>; 64],
     hashed_message_inputs: &[FunctionInput<F>; 32],
+    predicate: &FunctionInput<F>,
     output: Witness,
 ) -> Result<(), OpcodeResolutionError<F>> {
     let pub_key_x: [u8; 32] = to_u8_array(initial_witness, public_key_x_inputs)?;
     let pub_key_y: [u8; 32] = to_u8_array(initial_witness, public_key_y_inputs)?;
     let signature: [u8; 64] = to_u8_array(initial_witness, signature_inputs)?;
     let hashed_message: [u8; 32] = to_u8_array(initial_witness, hashed_message_inputs)?;
-
-    let is_valid = ecdsa_secp256k1_verify(&hashed_message, &pub_key_x, &pub_key_y, &signature)?;
+    let predicate = input_to_value(initial_witness, *predicate)?.is_one();
+    let is_valid = if predicate {
+        ecdsa_secp256k1_verify(&hashed_message, &pub_key_x, &pub_key_y, &signature)?
+    } else {
+        true
+    };
 
     insert_value(&output, F::from(is_valid), initial_witness)
 }
@@ -34,14 +39,19 @@ pub(crate) fn secp256r1_prehashed<F: AcirField>(
     public_key_y_inputs: &[FunctionInput<F>; 32],
     signature_inputs: &[FunctionInput<F>; 64],
     hashed_message_inputs: &[FunctionInput<F>; 32],
+    predicate: &FunctionInput<F>,
     output: Witness,
 ) -> Result<(), OpcodeResolutionError<F>> {
     let pub_key_x: [u8; 32] = to_u8_array(initial_witness, public_key_x_inputs)?;
     let pub_key_y: [u8; 32] = to_u8_array(initial_witness, public_key_y_inputs)?;
     let signature: [u8; 64] = to_u8_array(initial_witness, signature_inputs)?;
     let hashed_message: [u8; 32] = to_u8_array(initial_witness, hashed_message_inputs)?;
-
-    let is_valid = ecdsa_secp256r1_verify(&hashed_message, &pub_key_x, &pub_key_y, &signature)?;
+    let predicate = input_to_value(initial_witness, *predicate)?.is_one();
+    let is_valid = if predicate {
+        ecdsa_secp256r1_verify(&hashed_message, &pub_key_x, &pub_key_y, &signature)?
+    } else {
+        true
+    };
 
     insert_value(&output, F::from(is_valid), initial_witness)
 }

acvm-repo/blackbox_solver/src/curve_specific_solver.rs

@@ -13,7 +13,10 @@ pub trait BlackBoxFunctionSolver<F> {
         points: &[F],
         scalars_lo: &[F],
         scalars_hi: &[F],
+        predicate: bool,
     ) -> Result<(F, F, F), BlackBoxResolutionError>;
+
+    #[allow(clippy::too_many_arguments)]
     fn ec_add(
         &self,
         input1_x: &F,
@@ -22,6 +25,7 @@ pub trait BlackBoxFunctionSolver<F> {
         input2_x: &F,
         input2_y: &F,
         input2_infinite: &F,
+        predicate: bool,
     ) -> Result<(F, F, F), BlackBoxResolutionError>;
     fn poseidon2_permutation(&self, inputs: &[F]) -> Result<Vec<F>, BlackBoxResolutionError>;
 }
@@ -55,6 +59,7 @@ impl<F> BlackBoxFunctionSolver<F> for StubbedBlackBoxSolver {
         _points: &[F],
         _scalars_lo: &[F],
         _scalars_hi: &[F],
+        _predicate: bool,
     ) -> Result<(F, F, F), BlackBoxResolutionError> {
         Err(Self::fail(BlackBoxFunc::MultiScalarMul))
     }
@@ -66,6 +71,7 @@ impl<F> BlackBoxFunctionSolver<F> for StubbedBlackBoxSolver {
         _input2_x: &F,
         _input2_y: &F,
         _input2_infinite: &F,
+        _predicate: bool,
     ) -> Result<(F, F, F), BlackBoxResolutionError> {
         Err(Self::fail(BlackBoxFunc::EmbeddedCurveAdd))
     }

acvm-repo/bn254_blackbox_solver/src/lib.rs

@@ -1,5 +1,6 @@
 #![cfg_attr(not(test), warn(unused_crate_dependencies, unused_extern_crates))]
 
+use acir::AcirField;
 use acvm_blackbox_solver::{BlackBoxFunctionSolver, BlackBoxResolutionError};
 
 mod embedded_curve_ops;
@@ -30,8 +31,13 @@ impl BlackBoxFunctionSolver<FieldElement> for Bn254BlackBoxSolver {
         points: &[FieldElement],
         scalars_lo: &[FieldElement],
         scalars_hi: &[FieldElement],
+        predicate: bool,
     ) -> Result<(FieldElement, FieldElement, FieldElement), BlackBoxResolutionError> {
-        multi_scalar_mul(points, scalars_lo, scalars_hi, self.pedantic_solving())
+        if predicate {
+            multi_scalar_mul(points, scalars_lo, scalars_hi, self.pedantic_solving())
+        } else {
+            Ok((FieldElement::zero(), FieldElement::zero(), FieldElement::one()))
+        }
     }
 
     fn ec_add(
@@ -42,12 +48,17 @@ impl BlackBoxFunctionSolver<FieldElement> for Bn254BlackBoxSolver {
         input2_x: &FieldElement,
         input2_y: &FieldElement,
         input2_infinite: &FieldElement,
+        predicate: bool,
     ) -> Result<(FieldElement, FieldElement, FieldElement), BlackBoxResolutionError> {
-        embedded_curve_add(
-            [*input1_x, *input1_y, *input1_infinite],
-            [*input2_x, *input2_y, *input2_infinite],
-            self.pedantic_solving(),
-        )
+        if predicate {
+            embedded_curve_add(
+                [*input1_x, *input1_y, *input1_infinite],
+                [*input2_x, *input2_y, *input2_infinite],
+                self.pedantic_solving(),
+            )
+        } else {
+            Ok((FieldElement::zero(), FieldElement::zero(), FieldElement::one()))
+        }
     }
 
     fn poseidon2_permutation(

acvm-repo/brillig_vm/src/black_box.rs

@@ -220,7 +220,12 @@ pub(crate) fn evaluate_black_box<F: AcirField, Solver: BlackBoxFunctionSolver<F>
                     scalars_hi.push(*scalar);
                 }
             }
-            let (x, y, is_infinite) = solver.multi_scalar_mul(&points, &scalars_lo, &scalars_hi)?;
+            let (x, y, is_infinite) = solver.multi_scalar_mul(
+                &points,
+                &scalars_lo,
+                &scalars_hi,
+                true, // Predicate is always true as brillig has control flow to handle false case
+            )?;
             write_heap_array(
                 memory,
                 result,
@@ -254,6 +259,7 @@ pub(crate) fn evaluate_black_box<F: AcirField, Solver: BlackBoxFunctionSolver<F>
                 &input2_x,
                 &input2_y,
                 &input2_infinite.into(),
+                true, // Predicate is always true as brillig has control flow to handle false case
             )?;
 
             write_heap_array(