chore(ACIR): better display/parse for blackbox calls

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

@@ -545,7 +545,7 @@ mod tests {
         return values: [w2]
         ASSERT 0 = 2*w1 + 8
         BLACKBOX::RANGE input: w1, bits: 8
-        BLACKBOX::AND inputs: [w1, w2], bits: 4, output: w3
+        BLACKBOX::AND lhs: w1, rhs: w2, output: w3, bits: 4
         BLACKBOX::KECCAKF1600 inputs: [w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15, w16, w17, w18, w19, w20, w21, w22, w23, w24, w25], outputs: [w26, w27, w28, w29, w30, w31, w32, w33, w34, w35, w36, w37, w38, w39, w40, w41, w42, w43, w44, w45, w46, w47, w48, w49, w50]
         "
         );

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

@@ -258,7 +258,7 @@ mod tests {
 
         insta::assert_snapshot!(
             xor.to_string(),
-            @"BLACKBOX::XOR inputs: [w0, w1], bits: 32, output: w3"
+            @"BLACKBOX::XOR lhs: w0, rhs: w1, output: w3, bits: 32"
         );
     }
 

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

@@ -435,36 +435,113 @@ impl<F: std::fmt::Display + Copy> std::fmt::Display for BlackBoxFuncCall<F> {
         let uppercase_name = self.name().to_uppercase();
         write!(f, "BLACKBOX::{uppercase_name} ")?;
 
-        // inputs
-        let inputs = &self.get_inputs_vec();
-        let inputs_str = inputs.iter().map(|i| i.to_string()).collect::<Vec<String>>().join(", ");
-        if inputs.len() == 1 {
-            write!(f, "input: {inputs_str}")?;
-        } else {
-            write!(f, "inputs: [{inputs_str}]")?;
-        }
-
-        // bits
-        if let Some(bit_size) = self.bit_size() {
-            write!(f, ", bits: {bit_size}")?;
-        }
-
-        // outputs
-        let outputs = &self.get_outputs_vec();
-        if !outputs.is_empty() {
-            let outputs_str =
-                outputs.iter().map(ToString::to_string).collect::<Vec<String>>().join(", ");
-            if outputs.len() == 1 {
-                write!(f, ", output: {outputs_str}")?;
-            } else {
-                write!(f, ", outputs: [{outputs_str}]")?;
+        match self {
+            BlackBoxFuncCall::AES128Encrypt { inputs, iv, key, outputs } => {
+                let inputs = slice_to_string(inputs);
+                let iv = slice_to_string(&iv.to_vec());
+                let key = slice_to_string(&key.to_vec());
+                let outputs = slice_to_string(outputs);
+                write!(f, "inputs: {inputs}, iv: {iv}, key: {key}, outputs: {outputs}")?;
+            }
+            BlackBoxFuncCall::AND { lhs, rhs, num_bits, output }
+            | BlackBoxFuncCall::XOR { lhs, rhs, num_bits, output } => {
+                write!(f, "lhs: {lhs}, rhs: {rhs}, output: {output}, bits: {num_bits}")?;
+            }
+            BlackBoxFuncCall::RANGE { input, num_bits } => {
+                write!(f, "input: {input}, bits: {num_bits}")?;
+            }
+            BlackBoxFuncCall::Blake2s { inputs, outputs }
+            | BlackBoxFuncCall::Blake3 { inputs, outputs } => {
+                let inputs = slice_to_string(inputs);
+                let outputs = slice_to_string(&outputs.to_vec());
+                write!(f, "inputs: {inputs}, outputs: {outputs}")?;
+            }
+            BlackBoxFuncCall::EcdsaSecp256k1 {
+                public_key_x,
+                public_key_y,
+                signature,
+                hashed_message,
+                predicate,
+                output,
+            }
+            | BlackBoxFuncCall::EcdsaSecp256r1 {
+                public_key_x,
+                public_key_y,
+                signature,
+                hashed_message,
+                predicate,
+                output,
+            } => {
+                let public_key_x = slice_to_string(&public_key_x.to_vec());
+                let public_key_y = slice_to_string(&public_key_y.to_vec());
+                let signature = slice_to_string(&signature.to_vec());
+                let hashed_message = slice_to_string(&hashed_message.to_vec());
+                write!(
+                    f,
+                    "public_key_x: {public_key_x}, public_key_y: {public_key_y}, signature: {signature}, hashed_message: {hashed_message}, predicate: {predicate}, output: {output}"
+                )?;
+            }
+            BlackBoxFuncCall::MultiScalarMul { points, scalars, predicate, outputs } => {
+                let points = slice_to_string(points);
+                let scalars = slice_to_string(scalars);
+                write!(
+                    f,
+                    "points: {points}, scalars: {scalars}, predicate: {predicate}, outputs: [{}, {}, {}]",
+                    outputs.0, outputs.1, outputs.2
+                )?;
+            }
+            BlackBoxFuncCall::EmbeddedCurveAdd { input1, input2, predicate, outputs } => {
+                let input1 = slice_to_string(&input1.to_vec());
+                let input2 = slice_to_string(&input2.to_vec());
+                write!(
+                    f,
+                    "input1: {input1}, input2: {input2}, predicate: {predicate}, outputs: [{}, {}, {}]",
+                    outputs.0, outputs.1, outputs.2
+                )?;
+            }
+            BlackBoxFuncCall::Keccakf1600 { inputs, outputs } => {
+                let inputs = slice_to_string(&inputs.to_vec());
+                let outputs = slice_to_string(&outputs.to_vec());
+                write!(f, "inputs: {inputs}, outputs: {outputs}")?;
+            }
+            BlackBoxFuncCall::RecursiveAggregation {
+                verification_key,
+                proof,
+                public_inputs,
+                key_hash,
+                proof_type,
+                predicate,
+            } => {
+                let verification_key = slice_to_string(verification_key);
+                let proof = slice_to_string(proof);
+                let public_inputs = slice_to_string(public_inputs);
+                write!(
+                    f,
+                    "verification_key: {verification_key}, proof: {proof}, public_inputs: {public_inputs}, key_hash: {key_hash}, proof_type: {proof_type}, predicate: {predicate}"
+                )?;
+            }
+            BlackBoxFuncCall::Poseidon2Permutation { inputs, outputs } => {
+                let inputs = slice_to_string(inputs);
+                let outputs = slice_to_string(outputs);
+                write!(f, "inputs: {inputs}, outputs: {outputs}")?;
+            }
+            BlackBoxFuncCall::Sha256Compression { inputs, hash_values, outputs } => {
+                let inputs = slice_to_string(&inputs.to_vec());
+                let hash_values = slice_to_string(&hash_values.to_vec());
+                let outputs = slice_to_string(&outputs.to_vec());
+                write!(f, "inputs: {inputs}, hash_values: {hash_values}, outputs: {outputs}")?;
             }
         }
 
         Ok(())
     }
 }
 
+fn slice_to_string<D: std::fmt::Display>(inputs: &[D]) -> String {
+    let inputs = inputs.iter().map(|i| i.to_string()).collect::<Vec<String>>().join(", ");
+    format!("[{inputs}]")
+}
+
 impl<F: std::fmt::Display + Copy> std::fmt::Debug for BlackBoxFuncCall<F> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self, f)