refactor: serialization-related macros cleanup (#15834)

In this PR I
- replace the last use of `generate_serialize_to_fields` and I delete
the function
- rename `get_note_interface` as `get_note_type_impl` (the naming was
stale)
- I replace use of `get_packable_len` as the function didn't work on
types whose Packable implementation included numeric generics (in that
case the return type length was not yet resolved and conversion to
constant failed). Instead of using the func I insert a static assert
into the note implementation,
- instead of loading note packed length from `NOTES` hash map in
`#[aztec]` macro I use `<NoteType as Packable>::N` which significantly
simplifies the macros

Author: benesjan

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

@@ -9,7 +9,7 @@ mod oracle;
 mod state_vars;
 mod capsules;
 mod event;
-mod messages;
+pub mod messages;
 pub use dep::protocol_types;
 mod utils;
 mod authwit;

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

@@ -119,17 +119,15 @@ comptime fn generate_contract_interface(m: Module) -> Quoted {
 /// discovery (to create the `aztec::messages::discovery::ComputeNoteHashAndNullifier` function) and to implement the
 /// `compute_note_hash_and_nullifier` unconstrained contract function.
 comptime fn generate_contract_library_method_compute_note_hash_and_nullifier() -> Quoted {
-    let notes = NOTES.entries();
-
-    if notes.len() > 0 {
+    if NOTES.len() > 0 {
         // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the
         // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we
         // know it we call we correct `unpack` method from the `Packable` trait to obtain the underlying note type, and
         // compute the note hash (non-siloed) and inner nullifier (also non-siloed).
 
         let mut if_note_type_id_match_statements_list = &[];
-        for i in 0..notes.len() {
-            let (typ, packed_note_length) = notes[i];
+        for i in 0..NOTES.len() {
+            let typ = NOTES.get(i);
 
             let get_note_type_id = get_trait_impl_method(
                 typ,
@@ -166,7 +164,7 @@ comptime fn generate_contract_library_method_compute_note_hash_and_nullifier() -
                         // As an extra safety check we make sure that the packed_note BoundedVec has the expected
                         // length, since we're about to interpret its raw storage as a fixed-size array by calling the
                         // unpack function on it.
-                        let expected_len = $packed_note_length;
+                        let expected_len = <$typ as $crate::protocol_types::traits::Packable>::N;
                         let actual_len = packed_note.len();
                         assert(
                             actual_len == expected_len,

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

@@ -11,7 +11,6 @@ use crate::macros::{
         module_has_storage,
     },
 };
-use protocol_types::meta::generate_serialize_to_fields;
 use std::meta::{ctstring::AsCtString, type_of};
 
 pub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {
@@ -208,17 +207,26 @@ pub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {
 
     // Public functions undergo a lot of transformations from their Aztec.nr form.
     let original_params = f.parameters();
-    let args_len = original_params
-        .map(|(name, typ): (Quoted, Type)| {
-            generate_serialize_to_fields(name, typ, false).0.len()
-        })
-        .fold(0, |acc: u32, val: u32| acc + val);
+
+    let args_len_quote = if original_params.len() == 0 {
+        // If the function has no parameters, we set the args_len to 0.
+        quote { 0 }
+    } else {
+        // The following will give us <type_of_struct_member_1 as Serialize>::N + <type_of_struct_member_2 as Serialize>::N + ...
+        original_params
+            .map(|(_, param_type): (Quoted, Type)| {
+                quote {
+            <$param_type as $crate::protocol_types::traits::Serialize>::N
+        }
+            })
+            .join(quote {+})
+    };
 
     // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.
     let context_creation = quote {
         let mut context = dep::aztec::context::public_context::PublicContext::new(|| {
         // We start from 1 because we skip the selector for the dispatch function.
-        let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);
+        let serialized_args : [Field; $args_len_quote] = dep::aztec::context::public_context::calldata_copy(1, $args_len_quote);
         dep::aztec::hash::hash_args_array(serialized_args)
         });
     };

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

@@ -1,23 +1,20 @@
-use crate::{
-    messages::discovery::private_notes::MAX_NOTE_PACKED_LEN,
-    note::note_getter_options::PropertySelector,
-};
-use poseidon::poseidon2::Poseidon2Hasher;
-use protocol_types::meta::get_packable_len;
-use std::{collections::umap::UHashMap, hash::BuildHasherDefault, meta::type_of};
+use crate::note::note_getter_options::PropertySelector;
+use std::{collections::bounded_vec::BoundedVec, meta::type_of};
 
-/// A map from note type to note_packed_len.
-pub comptime mut global NOTES: UHashMap<Type, u32, BuildHasherDefault<Poseidon2Hasher>> =
-    UHashMap::default();
+/// Maximum number of note types within 1 contract.
+comptime global MAX_NOTE_TYPES: u32 = 128;
+
+/// A BoundedVec containing all the note types within this contract.
+pub comptime mut global NOTES: BoundedVec<Type, MAX_NOTE_TYPES> = BoundedVec::new();
 
 comptime mut global NOTE_TYPE_ID_COUNTER: u32 = 0;
 
 /// The note type id is set by enumerating the note types.
 comptime fn get_next_note_type_id() -> Field {
     // We assert that the note type id fits within 7 bits
     assert(
-        NOTE_TYPE_ID_COUNTER < 128 as u32,
-        "A contract can contain at most 128 different note types",
+        NOTE_TYPE_ID_COUNTER < MAX_NOTE_TYPES,
+        f"A contract can contain at most {MAX_NOTE_TYPES} different note types",
     );
 
     let note_type_id = NOTE_TYPE_ID_COUNTER as Field;
@@ -32,12 +29,21 @@ comptime fn get_next_note_type_id() -> Field {
 ///         ...
 ///     }
 /// }
-comptime fn generate_note_interface(s: TypeDefinition, note_type_id: Field) -> Quoted {
+comptime fn generate_note_type_impl(s: TypeDefinition, note_type_id: Field) -> Quoted {
     let name = s.name();
+    let typ = s.as_type();
+
+    // TODO: Insert note type name into the static assert message. Currently blocked by:
+    // https://github.com/noir-lang/noir/issues/9274
 
     quote {
         impl aztec::note::note_interface::NoteType for $name {
             fn get_id() -> Field {
+                // This static assertion ensures the note's packed length doesn't exceed the maximum allowed size.
+                // While this check would ideally live in the Packable trait implementation, we place it here since
+                // this function is always generated by our macros and the Packable trait implementation is not.
+                let max_packed_len = $crate::messages::discovery::private_notes::MAX_NOTE_PACKED_LEN;
+                std::static_assert(<$typ as Packable>::N  <= max_packed_len, f"Note packed length exceeds the maximum of {max_packed_len} fields");
                 $note_type_id
             }
         }
@@ -174,40 +180,30 @@ comptime fn generate_note_properties(s: TypeDefinition) -> Quoted {
 ///
 /// # Registration
 ///
-/// Registers the note in the global `NOTES` map to enable note processing functionality.
+/// Registers the note in the global `NOTES` BoundedVec to enable note processing functionality.
 ///
 /// # Generated Code
 ///
 /// For detailed documentation on the generated implementations, see:
 /// - `generate_note_properties()`
-/// - `generate_note_interface()`
+/// - `generate_note_type_impl()`
 /// - `generate_note_hash_trait_impl()`
 pub comptime fn note(s: TypeDefinition) -> Quoted {
     assert_has_owner(s);
     assert_has_packable(s);
 
-    let note_packed_len = get_packable_len(s.as_type());
-
-    // Ensure the note's packed length does not exceed the maximum allowable size to prevent overflow
-    // when processing the note.
-    if note_packed_len > MAX_NOTE_PACKED_LEN {
-        panic(
-            f"{s} packs into {note_packed_len} fields which is larger than the maximum of {MAX_NOTE_PACKED_LEN}",
-        );
-    }
-
-    // We register the note in the global `NOTES` map with the packed length because we need that information
-    // inside the #[aztec] macro to generate note processing functionality.
-    NOTES.insert(s.as_type(), note_packed_len);
+    // We register the note in the global `NOTES` BoundedVec because we need that information inside the #[aztec] macro
+    // to generate note processing functionality.
+    NOTES.push(s.as_type());
 
     let note_properties = generate_note_properties(s);
     let note_type_id = get_next_note_type_id();
-    let note_interface_impl = generate_note_interface(s, note_type_id);
+    let note_type_impl = generate_note_type_impl(s, note_type_id);
     let note_hash_impl = generate_note_hash_trait_impl(s);
 
     quote {
         $note_properties
-        $note_interface_impl
+        $note_type_impl
         $note_hash_impl
     }
 }
@@ -227,9 +223,8 @@ pub comptime fn note(s: TypeDefinition) -> Quoted {
 /// Unlike the `#[note]` macro, there is no requirement for an `owner` field.
 ///
 /// # Registration
-/// Registers the note in the global `NOTES` map with:
-/// - Note type ID
-/// - Packed length
+///
+/// Registers the note in the global `NOTES` BoundedVec to enable note processing functionality.
 ///
 /// # Use Cases
 /// Use this macro when implementing a note that needs custom:
@@ -258,27 +253,17 @@ pub comptime fn note(s: TypeDefinition) -> Quoted {
 pub comptime fn custom_note(s: TypeDefinition) -> Quoted {
     assert_has_packable(s);
 
-    let note_packed_len = get_packable_len(s.as_type());
-
-    // Ensure the note's packed length does not exceed the maximum allowable size to prevent overflow
-    // when processing the note.
-    if note_packed_len > MAX_NOTE_PACKED_LEN {
-        panic(
-            f"{s} packs into {note_packed_len} fields which is larger than the maximum of {MAX_NOTE_PACKED_LEN}",
-        );
-    }
-
-    // We register the note in the global `NOTES` map with the packed length because we need that information
-    // inside the #[aztec] macro to generate note processing functionality.
-    NOTES.insert(s.as_type(), note_packed_len);
+    // We register the note in the global `NOTES` BoundedVec because we need that information inside the #[aztec] macro
+    // to generate note processing functionality.
+    NOTES.push(s.as_type());
 
     let note_type_id = get_next_note_type_id();
     let note_properties = generate_note_properties(s);
-    let note_interface_impl = generate_note_interface(s, note_type_id);
+    let note_type_impl = generate_note_type_impl(s, note_type_id);
 
     quote {
         $note_properties
-        $note_interface_impl
+        $note_type_impl
     }
 }
 

noir-projects/noir-contracts-comp-failures/contracts/invalid_note/Nargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "invalid_note"
+authors = [""]
+compiler_version = ">=0.25.0"
+type = "contract"
+
+[dependencies]
+aztec = { path = "../../../aztec-nr/aztec" }

noir-projects/noir-contracts-comp-failures/contracts/invalid_note/expected_error

@@ -0,0 +1 @@
+Note packed length exceeds the maximum of 12 fields

noir-projects/noir-contracts-comp-failures/contracts/invalid_note/src/invalid_note.nr

@@ -0,0 +1,22 @@
+use aztec::{
+    macros::notes::note,
+    messages::discovery::private_notes::MAX_NOTE_PACKED_LEN,
+    protocol_types::{address::AztecAddress, traits::{FromField, Packable}},
+};
+
+#[note]
+pub struct InvalidNote {
+    pub owner: AztecAddress,
+}
+
+impl Packable for InvalidNote {
+    let N: u32 = MAX_NOTE_PACKED_LEN + 1;
+
+    fn pack(self) -> [Field; Self::N] {
+        std::mem::zeroed()
+    }
+
+    fn unpack(packed: [Field; Self::N]) -> Self {
+        Self { owner: AztecAddress::from_field(packed[0]) }
+    }
+}

noir-projects/noir-contracts-comp-failures/contracts/invalid_note/src/main.nr

@@ -0,0 +1,7 @@
+use aztec::macros::aztec;
+
+mod invalid_note;
+
+#[aztec]
+pub contract InvalidNoteContract {
+}