From a96ef7285c2b0eb5eddb8df1e3950c4dcece5851 Mon Sep 17 00:00:00 2001
From: TomAFrench <tom@tomfren.ch>
Date: Thu, 20 Jul 2023 03:19:01 +0000
Subject: [PATCH] chore: create helper function to get byte array

---
 .../src/ssa_refactor/ir/instruction.rs        | 68 ++++++-------------
 1 file changed, 21 insertions(+), 47 deletions(-)

diff --git a/crates/noirc_evaluator/src/ssa_refactor/ir/instruction.rs b/crates/noirc_evaluator/src/ssa_refactor/ir/instruction.rs
index 1a7fa09de29..c58de7be423 100644
--- a/crates/noirc_evaluator/src/ssa_refactor/ir/instruction.rs
+++ b/crates/noirc_evaluator/src/ssa_refactor/ir/instruction.rs
@@ -397,6 +397,16 @@ fn simplify_call(func: ValueId, arguments: &[ValueId], dfg: &mut DataFlowGraph)
     let constant_args: Option<Vec<_>> =
         arguments.iter().map(|value_id| dfg.get_numeric_constant(*value_id)).collect();
 
+    fn to_u8_vec(dfg: &DataFlowGraph, values: im::Vector<Id<Value>>) -> Vec<u8> {
+        values
+            .iter()
+            .map(|id| {
+                let field = dfg.get_numeric_constant(*id).unwrap();
+                *field.to_be_bytes().last().unwrap()
+            })
+            .collect()
+    }
+
     match intrinsic {
         Intrinsic::ToBits(endian) => {
             if let Some(constant_args) = constant_args {
@@ -526,10 +536,7 @@ fn simplify_call(func: ValueId, arguments: &[ValueId], dfg: &mut DataFlowGraph)
             }
             BlackBoxFunc::SHA256 => {
                 if let Some((input, _)) = dfg.get_array_constant(arguments[0]) {
-                    let inputs: Vec<FieldElement> =
-                        input.into_iter().map(|id| dfg.get_numeric_constant(id).unwrap()).collect();
-                    let input_bytes: Vec<u8> =
-                        vecmap(inputs, |field| *field.to_be_bytes().last().unwrap());
+                    let input_bytes: Vec<u8> = to_u8_vec(dfg, input);
 
                     let hash = acvm::blackbox_solver::sha256(&input_bytes).unwrap();
 
@@ -550,10 +557,7 @@ fn simplify_call(func: ValueId, arguments: &[ValueId], dfg: &mut DataFlowGraph)
             }
             BlackBoxFunc::Blake2s => {
                 if let Some((input, _)) = dfg.get_array_constant(arguments[0]) {
-                    let inputs: Vec<FieldElement> =
-                        input.into_iter().map(|id| dfg.get_numeric_constant(id).unwrap()).collect();
-                    let input_bytes: Vec<u8> =
-                        vecmap(inputs, |field| *field.to_be_bytes().last().unwrap());
+                    let input_bytes: Vec<u8> = to_u8_vec(dfg, input);
 
                     let hash = acvm::blackbox_solver::blake2s(&input_bytes).unwrap();
 
@@ -574,10 +578,7 @@ fn simplify_call(func: ValueId, arguments: &[ValueId], dfg: &mut DataFlowGraph)
             }
             BlackBoxFunc::HashToField128Security => {
                 if let Some((input, _)) = dfg.get_array_constant(arguments[0]) {
-                    let inputs: Vec<FieldElement> =
-                        input.into_iter().map(|id| dfg.get_numeric_constant(id).unwrap()).collect();
-                    let input_bytes: Vec<u8> =
-                        vecmap(inputs, |field| *field.to_be_bytes().last().unwrap());
+                    let input_bytes: Vec<u8> = to_u8_vec(dfg, input);
 
                     let field =
                         acvm::blackbox_solver::hash_to_field_128_security(&input_bytes).unwrap();
@@ -592,10 +593,7 @@ fn simplify_call(func: ValueId, arguments: &[ValueId], dfg: &mut DataFlowGraph)
                 if let (Some((input, _)), Some(num_bytes)) =
                     (dfg.get_array_constant(arguments[0]), dfg.get_numeric_constant(arguments[1]))
                 {
-                    let inputs: Vec<FieldElement> =
-                        input.into_iter().map(|id| dfg.get_numeric_constant(id).unwrap()).collect();
-                    let input_bytes: Vec<u8> =
-                        vecmap(inputs, |field| *field.to_be_bytes().last().unwrap());
+                    let input_bytes: Vec<u8> = to_u8_vec(dfg, input);
 
                     let num_bytes = num_bytes.to_u128() as usize;
                     let truncated_input_bytes = &input_bytes[0..num_bytes];
@@ -629,40 +627,16 @@ fn simplify_call(func: ValueId, arguments: &[ValueId], dfg: &mut DataFlowGraph)
                     dfg.get_array_constant(arguments[2]),
                     dfg.get_array_constant(arguments[3]),
                 ) {
-                    let public_key_x: Vec<u8> = pubkey_x
-                        .into_iter()
-                        .map(|id| {
-                            let field = dfg.get_numeric_constant(id).unwrap();
-                            *field.to_be_bytes().last().unwrap()
-                        })
-                        .collect();
-                    let public_key_y: Vec<u8> = pubkey_y
-                        .into_iter()
-                        .map(|id| {
-                            let field = dfg.get_numeric_constant(id).unwrap();
-                            *field.to_be_bytes().last().unwrap()
-                        })
-                        .collect();
-                    let signature: Vec<u8> = signature
-                        .into_iter()
-                        .map(|id| {
-                            let field = dfg.get_numeric_constant(id).unwrap();
-                            *field.to_be_bytes().last().unwrap()
-                        })
-                        .collect();
-                    let hashed_message: Vec<u8> = hashed_message
-                        .into_iter()
-                        .map(|id| {
-                            let field = dfg.get_numeric_constant(id).unwrap();
-                            *field.to_be_bytes().last().unwrap()
-                        })
-                        .collect();
+                    let public_key_x: [u8; 32] = to_u8_vec(dfg, pubkey_x).try_into().unwrap();
+                    let public_key_y: [u8; 32] = to_u8_vec(dfg, pubkey_y).try_into().unwrap();
+                    let signature: [u8; 64] = to_u8_vec(dfg, signature).try_into().unwrap();
+                    let hashed_message: Vec<u8> = to_u8_vec(dfg, hashed_message);
 
                     let valid_signature = acvm::blackbox_solver::ecdsa_secp256k1_verify(
                         &hashed_message,
-                        &public_key_x.try_into().unwrap(),
-                        &public_key_y.try_into().unwrap(),
-                        &signature.try_into().unwrap(),
+                        &public_key_x,
+                        &public_key_y,
+                        &signature,
                     )
                     .unwrap();