refactor: dropping now-unnecessary ArgsHasher

I noticed that we can reuse the functionality I extracted out of `derive_serialize` yesterday in [this PR](#17854) also for the hashing of contract function args and return values so I decided to do this PR as well.

Now we have a much better code reuse which is great.

Author: benesjan

noir-projects/aztec-nr/aztec/src/context/private_context.nr

@@ -1,6 +1,6 @@
 use crate::{
     context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},
-    hash::{ArgsHasher, hash_args_array, hash_calldata_array},
+    hash::{hash_args_array, hash_calldata_array},
     keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},
     messaging::process_l1_to_l2_message,
     oracle::{
@@ -562,11 +562,12 @@ impl PrivateContext {
     /// Very low-level function: this is called by the #[private] macro.
     ///
     /// # Arguments
-    /// * `returns_hasher` - A hasher containing the return values to hash
+    /// * `serialized_return_values` - The serialized return values as a field array
     ///
-    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {
-        self.return_hash = returns_hasher.hash();
-        execution_cache::store(returns_hasher.fields, self.return_hash);
+    pub fn set_return_hash<let N: u32>(&mut self, serialized_return_values: [Field; N]) {
+        let return_hash = hash_args_array(serialized_return_values);
+        self.return_hash = return_hash;
+        execution_cache::store(serialized_return_values, return_hash);
     }
 
     /// Builds the PrivateCircuitPublicInputs for this private function, to

noir-projects/aztec-nr/aztec/src/hash.nr

@@ -10,7 +10,7 @@ use dep::protocol_types::{
         sha256_to_field,
     },
     point::Point,
-    traits::{Hash, ToField},
+    traits::ToField,
 };
 
 pub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};
@@ -59,32 +59,6 @@ pub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) ->
     poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)
 }
 
-pub struct ArgsHasher {
-    pub fields: [Field],
-}
-
-impl Hash for ArgsHasher {
-    fn hash(self) -> Field {
-        hash_args(self.fields)
-    }
-}
-
-impl ArgsHasher {
-    pub fn new() -> Self {
-        Self { fields: [] }
-    }
-
-    pub fn add(&mut self, field: Field) {
-        self.fields = self.fields.push_back(field);
-    }
-
-    pub fn add_multiple<let N: u32>(&mut self, fields: [Field; N]) {
-        for i in 0..N {
-            self.fields = self.fields.push_back(fields[i]);
-        }
-    }
-}
-
 // Computes the hash of input arguments or return values for private functions, or for authwit creation.
 pub fn hash_args_array<let N: u32>(args: [Field; N]) -> Field {
     if args.len() == 0 {
@@ -149,11 +123,11 @@ pub fn compute_public_bytecode_commitment(
 
 #[test]
 unconstrained fn compute_var_args_hash() {
-    let mut input = ArgsHasher::new();
+    let mut input = [0; 100];
     for i in 0..100 {
-        input.add(i as Field);
+        input[i] = i as Field;
     }
-    let hash = input.hash();
+    let hash = hash_args_array(input);
     dep::std::println(hash);
     // Used in yarn-project/stdlib test snapshots:
     assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);

noir-projects/aztec-nr/aztec/src/macros/functions/utils.nr

@@ -4,12 +4,12 @@ use crate::macros::{
     },
     notes::NOTES,
     utils::{
-        add_to_hasher, fn_has_authorize_once, fn_has_noinitcheck, get_fn_visibility,
-        is_fn_contract_library_method, is_fn_initializer, is_fn_internal, is_fn_private,
-        is_fn_public, is_fn_test, is_fn_utility, is_fn_view, modify_fn_body, module_has_initializer,
-        module_has_storage,
+        fn_has_authorize_once, fn_has_noinitcheck, get_fn_visibility, is_fn_contract_library_method,
+        is_fn_initializer, is_fn_internal, is_fn_private, is_fn_public, is_fn_test, is_fn_utility,
+        is_fn_view, modify_fn_body, module_has_initializer, module_has_storage,
     },
 };
+use dep::protocol_types::meta::utils::derive_serialization_quotes;
 use std::meta::{ctstring::AsCtString, type_of};
 
 pub(crate) comptime fn transform_private(f: FunctionDefinition) {
@@ -34,24 +34,13 @@ pub(crate) comptime fn transform_private(f: FunctionDefinition) {
 
     // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received
     // the correct values.
-    // TODO: Optimize args_hasher for small number of arguments
-    let args_hasher_name = quote { args_hasher };
-    let args_hasher = original_params.fold(
-        quote {
-            let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();
-        },
-        |args_hasher, param: (Quoted, Type)| {
-            let (name, typ) = param;
-            let appended_arg = add_to_hasher(args_hasher_name, name, typ);
-            quote {
-                $args_hasher
-                $appended_arg
-            }
-        },
-    );
+    let (args_serialization, _, serialized_args_name) =
+        derive_serialization_quotes(original_params, false);
 
     let context_creation = quote {
-        let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, dep::aztec::protocol_types::traits::Hash::hash($args_hasher_name));
+        $args_serialization
+        let args_hash = dep::aztec::hash::hash_args_array($serialized_args_name);
+        let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, args_hash);
     };
 
     // Modifications introduced by the different marker attributes.
@@ -116,22 +105,21 @@ pub(crate) comptime fn transform_private(f: FunctionDefinition) {
     let return_value = if body.len() == 0 {
         quote {}
     } else if return_value_type != type_of(()) {
-        // The original return value is passed to a second args hasher which the context receives.
+        // The original return value is serialized and hashed before being passed to the context.
         let (body_without_return, last_body_expr) = body.pop_back();
         let return_value = last_body_expr.quoted();
         let return_value_assignment =
             quote { let $return_value_var_name: $return_value_type = $return_value; };
-        let return_hasher_name = quote { return_hasher };
-        let return_value_into_hasher =
-            add_to_hasher(return_hasher_name, return_value_var_name, return_value_type);
+
+        let (return_serialization, _, serialized_return_name) =
+            derive_serialization_quotes([(return_value_var_name, return_value_type)], false);
 
         body = body_without_return;
 
         quote {
-            let mut $return_hasher_name = dep::aztec::hash::ArgsHasher::new();
             $return_value_assignment
-            $return_value_into_hasher
-            context.set_return_hash($return_hasher_name);
+            $return_serialization
+            context.set_return_hash($serialized_return_name);
         }
     } else {
         let (body_without_return, last_body_expr) = body.pop_back();
@@ -154,7 +142,6 @@ pub(crate) comptime fn transform_private(f: FunctionDefinition) {
     // A quote to be injected at the beginning of the function body.
     let to_prepend = quote {
         dep::aztec::oracle::version::assert_compatible_oracle_version();
-        $args_hasher
         $context_creation
         $assert_initializer
         $init_check

noir-projects/aztec-nr/aztec/src/macros/utils.nr

@@ -72,40 +72,6 @@ pub(crate) comptime fn modify_fn_body(body: [Expr], prepend: Quoted, append: Quo
     body_expr.expect(f"Body is not an expression: {body_quote}")
 }
 
-/// Adds a value to a hash::ArgsHasher. Structs and values inside arrays are required to implement the Serialize trait.
-pub(crate) comptime fn add_to_hasher(hasher_name: Quoted, name: Quoted, typ: Type) -> Quoted {
-    if typ.is_field() | typ.as_integer().is_some() | typ.is_bool() {
-        quote { $hasher_name.add($name as Field); }
-    } else if typ.as_data_type().is_some() {
-        quote { $hasher_name.add_multiple(dep::aztec::protocol_types::traits::Serialize::serialize($name)); }
-    } else if typ.as_array().is_some() {
-        let (element_type, _) = typ.as_array().unwrap();
-        let serialized_name = f"{name}_serialized".quoted_contents();
-        quote {
-           let $serialized_name = $name.map(|x: $element_type | dep::aztec::protocol_types::traits::Serialize::serialize(x));
-            for i in 0..$name.len() {
-                $hasher_name.add_multiple($serialized_name[i]);
-            }
-        }
-    } else if typ.as_tuple().is_some() {
-        let tuple_len = typ.as_tuple().unwrap().len();
-        let mut tuple_quotes: [Quoted] = [];
-        for i in 0..tuple_len {
-            let element_quote = quote { $hasher_name.add_multiple(dep::aztec::protocol_types::traits::Serialize::serialize($name.$i)); };
-            tuple_quotes = tuple_quotes.push_back(element_quote);
-        }
-        tuple_quotes.join(quote {})
-    } else if typ.as_str().is_some() {
-        quote {
-            $hasher_name.add_multiple($name.as_bytes().map(| byte: u8 | byte as Field));
-        }
-    } else {
-        panic(
-            f"Cannot add to hasher: unsupported type {typ} of variable {name}",
-        )
-    }
-}
-
 comptime fn signature_of_type(typ: Type) -> Quoted {
     if typ.is_field() {
         quote {Field}

noir-projects/noir-contracts/contracts/docs/docs_example_contract/src/main.nr

@@ -12,7 +12,7 @@ pub contract DocsExample {
         macros::{functions::{private, public, utility}, storage::{storage, storage_no_init}},
         messages::message_delivery::MessageDelivery,
         note::{note_interface::NoteProperties, note_viewer_options::NoteViewerOptions},
-        protocol_types::{address::AztecAddress, traits::Hash},
+        protocol_types::address::AztecAddress,
         state_vars::{
             Map, PrivateImmutable, PrivateMutable, PrivateSet, PublicImmutable, PublicMutable,
         },
@@ -143,15 +143,14 @@ pub contract DocsExample {
     ) -> PrivateCircuitPublicInputs {
         // docs:end:context-example-return
         // ************************************************************
-        // The hasher is a structure used to generate a hash of the circuits inputs.
+        // The args are serialized and hashed to generate the args hash for the circuit inputs.
         // docs:start:context-example-hasher
-        let mut args_hasher = dep::aztec::hash::ArgsHasher::new();
-        args_hasher.add(a);
-        args_hasher.add(b);
+        let serialized_args = [a, b];
+        let args_hash = dep::aztec::hash::hash_args_array(serialized_args);
         // docs:end:context-example-hasher
         // The context object is created with the inputs and the hash of the inputs
         // docs:start:context-example-context
-        let mut context = PrivateContext::new(inputs, args_hasher.hash());
+        let mut context = PrivateContext::new(inputs, args_hash);
         // docs:end:context-example-context
         // docs:start:storage-example-context
         #[allow(unused_variables)]
@@ -161,11 +160,10 @@ pub contract DocsExample {
         // Our actual program
         let result = a + b;
         // ************************************************************
-        // Return values are pushed into the context
+        // Return values are serialized and passed to the context
         // docs:start:context-example-context-return
-        let mut return_hasher = dep::aztec::hash::ArgsHasher::new();
-        return_hasher.add(result);
-        context.set_return_hash(return_hasher);
+        let serialized_return = [result];
+        context.set_return_hash(serialized_return);
         // docs:end:context-example-context-return
         // The context is returned to be consumed by the kernel circuit!
         // docs:start:context-example-finish

noir-projects/noir-contracts/contracts/test/import_test_contract/src/main.nr

@@ -6,37 +6,10 @@ use dep::aztec::macros::aztec;
 pub contract ImportTest {
     use dep::aztec::protocol_types::address::AztecAddress;
 
-    use dep::test::Test::{self, DeepStruct, DummyNote};
+    use dep::test::Test;
 
     use dep::aztec::macros::functions::{private, public};
 
-    // Calls the test_code_gen on the Test contract at the target address
-    // Used for testing calling a function with arguments of multiple types
-    // See yarn-project/simulator/src/client/private_execution.ts
-    // See yarn-project/end-to-end/src/e2e_nested_contract.test.ts
-    #[private]
-    fn main_contract(target: AztecAddress) -> Field {
-        Test::at(target)
-            .test_code_gen(
-                1,
-                true,
-                1 as u32,
-                [1, 2],
-                DummyNote { amount: 1, secret_hash: 2 },
-                DeepStruct {
-                    a_field: 1,
-                    a_bool: true,
-                    a_note: DummyNote { amount: 1, secret_hash: 2 },
-                    many_notes: [
-                        DummyNote { amount: 1, secret_hash: 2 },
-                        DummyNote { amount: 1, secret_hash: 2 },
-                        DummyNote { amount: 1, secret_hash: 2 },
-                    ],
-                },
-            )
-            .call(&mut context)
-    }
-
     // Calls the get_this_address on the Test contract at the target address
     // Used for testing calling a function with no arguments
     // See yarn-project/end-to-end/src/e2e_nested_contract.test.ts

noir-projects/noir-contracts/contracts/test/test_contract/src/main.nr

@@ -37,7 +37,7 @@ pub contract Test {
         event::event_emission::emit_event_in_private,
         messages::message_delivery::MessageDelivery,
         // Hashing
-        hash::{ArgsHasher, pedersen_hash},
+        hash::pedersen_hash,
         // History and inclusion proofs
         history::note_inclusion::ProveNoteInclusion,
         // Key management
@@ -264,33 +264,6 @@ pub contract Test {
         header.prove_note_inclusion(retrieved_notes.get(0), storage_slot);
     }
 
-    #[private]
-    fn test_code_gen(
-        a_field: Field,
-        a_bool: bool,
-        a_number: u32,
-        an_array: [Field; 2],
-        a_struct: DummyNote,
-        a_deep_struct: DeepStruct,
-    ) -> Field {
-        let mut args = ArgsHasher::new();
-        args.add(a_field);
-        args.add(a_bool as Field);
-        args.add(a_number as Field);
-        args.add_multiple(an_array);
-        args.add(a_struct.amount);
-        args.add(a_struct.secret_hash);
-        args.add(a_deep_struct.a_field);
-        args.add(a_deep_struct.a_bool as Field);
-        args.add(a_deep_struct.a_note.amount);
-        args.add(a_deep_struct.a_note.secret_hash);
-        for note in a_deep_struct.many_notes {
-            args.add(note.amount);
-            args.add(note.secret_hash);
-        }
-        args.hash()
-    }
-
     #[private]
     fn test_setting_teardown() {
         context.set_public_teardown_function(

yarn-project/end-to-end/src/e2e_nested_contract/importer.test.ts

@@ -24,11 +24,6 @@ describe('e2e_nested_contract manual', () => {
     await t.teardown();
   });
 
-  it('calls a method with multiple arguments', async () => {
-    logger.info(`Calling main on importer contract`);
-    await importerContract.methods.main_contract(testContract.address).send({ from: defaultAccountAddress }).wait();
-  });
-
   it('calls a method no arguments', async () => {
     logger.info(`Calling noargs on importer contract`);
     await importerContract.methods.call_no_args(testContract.address).send({ from: defaultAccountAddress }).wait();