chore: implement Display for brillig

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

@@ -376,7 +376,10 @@ impl<F: AcirField> std::fmt::Display for Program<F> {
         }
         for (func_index, function) in self.unconstrained_functions.iter().enumerate() {
             writeln!(f, "unconstrained func {func_index}")?;
-            writeln!(f, "{:?}", function.bytecode)?;
+            let width = function.bytecode.len().to_string().len();
+            for (index, opcode) in function.bytecode.iter().enumerate() {
+                writeln!(f, "{index:>width$}: {opcode}")?;
+            }
         }
         Ok(())
     }

acvm-repo/brillig/src/black_box.rs

@@ -76,3 +76,105 @@ pub enum BlackBoxOp {
         output_bits: MemoryAddress,
     },
 }
+
+impl std::fmt::Display for BlackBoxOp {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            BlackBoxOp::AES128Encrypt { inputs, iv, key, outputs } => {
+                write!(
+                    f,
+                    "aes_128_encrypt(inputs: {inputs}, iv: {iv}, key: {key}, outputs: {outputs})"
+                )
+            }
+            BlackBoxOp::Blake2s { message, output } => {
+                write!(f, "blake2s(message: {message}, output: {output})")
+            }
+            BlackBoxOp::Blake3 { message, output } => {
+                write!(f, "blake3(message: {message}, output: {output})")
+            }
+            BlackBoxOp::Keccakf1600 { input, output } => {
+                write!(f, "keccakf1600(input: {input}, output: {output})")
+            }
+            BlackBoxOp::EcdsaSecp256k1 {
+                hashed_msg,
+                public_key_x,
+                public_key_y,
+                signature,
+                result,
+            } => {
+                write!(
+                    f,
+                    "ecdsa_secp256k1(hashed_msg: {hashed_msg}, public_key_x: {public_key_x}, public_key_y: {public_key_y}, signature: {signature}, result: {result})"
+                )
+            }
+            BlackBoxOp::EcdsaSecp256r1 {
+                hashed_msg,
+                public_key_x,
+                public_key_y,
+                signature,
+                result,
+            } => {
+                write!(
+                    f,
+                    "ecdsa_secp256r1(hashed_msg: {hashed_msg}, public_key_x: {public_key_x}, public_key_y: {public_key_y}, signature: {signature}, result: {result})"
+                )
+            }
+            BlackBoxOp::MultiScalarMul { points, scalars, outputs } => {
+                write!(
+                    f,
+                    "multi_scalar_mul(points: {points}, scalars: {scalars}, outputs: {outputs})"
+                )
+            }
+            BlackBoxOp::EmbeddedCurveAdd {
+                input1_x,
+                input1_y,
+                input1_infinite,
+                input2_x,
+                input2_y,
+                input2_infinite,
+                result,
+            } => {
+                write!(
+                    f,
+                    "embedded_curve_add(input1_x: {input1_x}, input1_y: {input1_y}, input1_infinite: {input1_infinite}, input2_x: {input2_x}, input2_y: {input2_y}, input2_infinite: {input2_infinite}, result: {result})"
+                )
+            }
+            BlackBoxOp::BigIntAdd { lhs, rhs, output } => {
+                write!(f, "big_int_add(lhs: {lhs}, rhs: {rhs}, output: {output})")
+            }
+            BlackBoxOp::BigIntSub { lhs, rhs, output } => {
+                write!(f, "big_int_sub(lhs: {lhs}, rhs: {rhs}, output: {output})")
+            }
+            BlackBoxOp::BigIntMul { lhs, rhs, output } => {
+                write!(f, "big_int_mul(lhs: {lhs}, rhs: {rhs}, output: {output})")
+            }
+            BlackBoxOp::BigIntDiv { lhs, rhs, output } => {
+                write!(f, "big_int_div(lhs: {lhs}, rhs: {rhs}, output: {output})")
+            }
+            BlackBoxOp::BigIntFromLeBytes { inputs, modulus, output } => {
+                write!(
+                    f,
+                    "big_int_from_le_bytes(inputs: {inputs}, modulus: {modulus}, output: {output})"
+                )
+            }
+            BlackBoxOp::BigIntToLeBytes { input, output } => {
+                write!(f, "big_int_to_le_bytes(input: {input}, output: {output})")
+            }
+            BlackBoxOp::Poseidon2Permutation { message, output, len } => {
+                write!(f, "poseidon2_permutation(message: {message}, len: {len}, output: {output})")
+            }
+            BlackBoxOp::Sha256Compression { input, hash_values, output } => {
+                write!(
+                    f,
+                    "sha256_compression(input: {input}, hash_values: {hash_values}, output: {output})"
+                )
+            }
+            BlackBoxOp::ToRadix { input, radix, output_pointer, num_limbs, output_bits } => {
+                write!(
+                    f,
+                    "to_radix(input: {input}, radix: {radix}, num_limbs: {num_limbs}, output_pointer: {output_pointer}, output_bits: {output_bits})"
+                )
+            }
+        }
+    }
+}