@aztec/protocol-contracts 5.0.0-nightly.20260421 → 5.0.0-nightly.20260422

package/artifacts/ContractInstanceRegistry.json

@@ -1402,27 +1402,27 @@
       "function_locations": [
         {
           "name": "derive_serialize",
-          "start": 3042
+          "start": 3018
         },
         {
           "name": "derive_deserialize",
-          "start": 7256
+          "start": 7206
         },
         {
           "name": "get_params_len_quote",
-          "start": 10978
+          "start": 10928
         },
         {
           "name": "get_generics_declarations",
-          "start": 11437
+          "start": 11387
         },
         {
           "name": "get_where_trait_clause",
-          "start": 12519
+          "start": 12469
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/serde/src/serialization.nr",
-      "source": "use crate::{reader::Reader, writer::Writer};\n\n// docs:start:serialize\n/// Trait for serializing Noir types into arrays of Fields.\n///\n/// An implementation of the Serialize trait has to follow Noir's intrinsic serialization (each member of a struct\n/// converted directly into one or more Fields without any packing or compression). This trait (and Deserialize) are\n/// typically used to communicate between Noir and TypeScript (via oracles and function arguments).\n///\n/// # On Following Noir's Intrinsic Serialization\n/// When calling a Noir function from TypeScript (TS), first the function arguments are serialized into an array\n/// of fields. This array is then included in the initial witness. Noir's intrinsic serialization is then used\n/// to deserialize the arguments from the witness. When the same Noir function is called from Noir this Serialize trait\n/// is used instead of the serialization in TS. For this reason we need to have a match between TS serialization,\n/// Noir's intrinsic serialization and the implementation of this trait. If there is a mismatch, the function calls\n/// fail with an arguments hash mismatch error message.\n///\n/// # Associated Constants\n/// * `N` - The length of the output Field array, known at compile time\n///\n/// # Example\n/// ```\n/// impl<let N: u32> Serialize for str<N> {\n///     let N: u32 = N;\n///\n///     fn serialize(self) -> [Field; Self::N] {\n///         let mut writer: Writer<Self::N> = Writer::new();\n///         self.stream_serialize(&mut writer);\n///         writer.finish()\n///     }\n///\n///     fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n///         let bytes = self.as_bytes();\n///         for i in 0..bytes.len() {\n///             writer.write(bytes[i] as Field);\n///         }\n///     }\n/// }\n/// ```\n#[derive_via(derive_serialize)]\npub trait Serialize {\n    let N: u32;\n\n    fn serialize(self) -> [Field; Self::N];\n\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>);\n}\n\n/// Generates a `Serialize` trait implementation for a struct type.\n///\n/// # Parameters\n/// - `s`: The struct type definition to generate the implementation for\n///\n/// # Returns\n/// A quoted code block containing the trait implementation\n///\n/// # Example\n/// For a struct defined as:\n/// ```\n/// struct Log<N> {\n///     fields: [Field; N],\n///     length: u32\n/// }\n/// ```\n///\n/// This function generates code equivalent to:\n/// ```\n/// impl<let N: u32> Serialize for Log<N> {\n///     let N: u32 = <[Field; N] as Serialize>::N + <u32 as Serialize>::N;\n///\n///     fn serialize(self) -> [Field; Self::N] {\n///         let mut writer: Writer<Self::N> = Writer::new();\n///         self.stream_serialize(&mut writer);\n///         writer.finish()\n///     }\n///\n///     #[inline_always]\n///     fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n///         Serialize::stream_serialize(self.fields, writer);\n///         Serialize::stream_serialize(self.length, writer);\n///     }\n/// }\n/// ```\npub comptime fn derive_serialize(s: TypeDefinition) -> Quoted {\n    let typ = s.as_type();\n    let nested_struct = typ.as_data_type().unwrap();\n\n    // We care only about the name and type so we drop the last item of the tuple\n    let params = nested_struct.0.fields(nested_struct.1).map(|(name, typ, _)| (name, typ));\n\n    // Generates the generic parameter declarations (to be placed after the `impl` keyword) and the `where` clause\n    // for the `Serialize` trait.\n    let generics_declarations = get_generics_declarations(s);\n    let where_serialize_clause = get_where_trait_clause(s, quote {Serialize});\n\n    let params_len_quote = get_params_len_quote(params);\n\n    let function_body = params\n        .map(|(name, _typ): (Quoted, Type)| {\n            quote {\n                $crate::serialization::Serialize::stream_serialize(self.$name, writer);\n            }\n        })\n        .join(quote {});\n\n    quote {\n        impl$generics_declarations $crate::serialization::Serialize for $typ\n            $where_serialize_clause\n        {\n            let N: u32 = $params_len_quote;\n\n\n            fn serialize(self) -> [Field; Self::N] {\n                let mut writer: $crate::writer::Writer<Self::N> = $crate::writer::Writer::new();\n                $crate::serialization::Serialize::stream_serialize(self, &mut writer);\n                writer.finish()\n            }\n\n\n            #[inline_always]\n             fn stream_serialize<let K: u32>(self, writer: &mut $crate::writer::Writer<K>) {\n                $function_body\n            }\n        }\n    }\n}\n\n// docs:start:deserialize\n/// Trait for deserializing Noir types from arrays of Fields.\n///\n/// An implementation of the Deserialize trait has to follow Noir's intrinsic serialization (each member of a struct\n/// converted directly into one or more Fields without any packing or compression). This trait is typically used when\n/// deserializing return values from function calls in Noir. Since the same function could be called from TypeScript\n/// (TS), in which case the TS deserialization would get used, we need to have a match between the 2.\n///\n/// # Associated Constants\n/// * `N` - The length of the input Field array, known at compile time\n///\n/// # Example\n/// ```\n/// impl<let M: u32> Deserialize for str<M> {\n///     let N: u32 = M;\n///\n///     fn deserialize(fields: [Field; Self::N]) -> Self {\n///         let mut reader = Reader::new(fields);\n///         let result = Self::stream_deserialize(&mut reader);\n///         reader.finish();\n///         result\n///     }\n///\n///     fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n///         let mut bytes = [0 as u8; M];\n///         for i in 0..M {\n///             bytes[i] = reader.read() as u8;\n///         }\n///         str::<M>::from(bytes)\n///     }\n/// }\n/// ```\n#[derive_via(derive_deserialize)]\npub trait Deserialize {\n    let N: u32;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self;\n\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self;\n}\n\n/// Generates a `Deserialize` trait implementation for a given struct `s`.\n///\n/// # Arguments\n/// * `s` - The struct type definition to generate the implementation for\n///\n/// # Returns\n/// A `Quoted` block containing the generated trait implementation\n///\n/// # Requirements\n/// Each struct member type must implement the `Deserialize` trait (it gets used in the generated code).\n///\n/// # Example\n/// For a struct like:\n/// ```\n/// struct MyStruct {\n///     x: AztecAddress,\n///     y: Field,\n/// }\n/// ```\n///\n/// This generates:\n/// ```\n/// impl Deserialize for MyStruct {\n///     let N: u32 = <AztecAddress as Deserialize>::N + <Field as Deserialize>::N;\n///\n///     fn deserialize(fields: [Field; Self::N]) -> Self {\n///         let mut reader = Reader::new(fields);\n///         let result = Self::stream_deserialize(&mut reader);\n///         reader.finish();\n///         result\n///     }\n///\n///     #[inline_always]\n///     fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n///         let x = <AztecAddress as Deserialize>::stream_deserialize(reader);\n///         let y = <Field as Deserialize>::stream_deserialize(reader);\n///         Self { x, y }\n///     }\n/// }\n/// ```\npub comptime fn derive_deserialize(s: TypeDefinition) -> Quoted {\n    let typ = s.as_type();\n    let nested_struct = typ.as_data_type().unwrap();\n    let params = nested_struct.0.fields(nested_struct.1);\n\n    // Generates the generic parameter declarations (to be placed after the `impl` keyword) and the `where` clause\n    // for the `Deserialize` trait.\n    let generics_declarations = get_generics_declarations(s);\n    let where_deserialize_clause = get_where_trait_clause(s, quote {Deserialize});\n\n    // The following will give us:\n    // <type_of_struct_member_1 as Deserialize>::N + <type_of_struct_member_2 as Deserialize>::N + ...\n    // (or 0 if the struct has no members)\n    let right_hand_side_of_definition_of_n = if params.len() > 0 {\n        params\n            .map(|(_, param_type, _): (Quoted, Type, Quoted)| {\n                quote {\n            <$param_type as $crate::serialization::Deserialize>::N\n        }\n            })\n            .join(quote {+})\n    } else {\n        quote {0}\n    };\n\n    // For structs containing a single member, we can enhance performance by directly deserializing the input array,\n    // bypassing the need for loop-based array construction. While this optimization yields significant benefits in\n    // Brillig where the loops are expected to not be optimized, it is not relevant in ACIR where the loops are\n    // expected to be optimized away.\n    let function_body = if params.len() > 1 {\n        // This generates deserialization code for each struct member and concatenates them together.\n        let deserialization_of_struct_members = params\n            .map(|(param_name, param_type, _): (Quoted, Type, Quoted)| {\n                quote {\n                    let $param_name = <$param_type as Deserialize>::stream_deserialize(reader);\n                }\n            })\n            .join(quote {});\n\n        // We join the struct member names with a comma to be used in the `Self { ... }` syntax\n        // This will give us e.g. `a, b, c` for a struct with three fields named `a`, `b`, and `c`.\n        let struct_members = params\n            .map(|(param_name, _, _): (Quoted, Type, Quoted)| quote { $param_name })\n            .join(quote {,});\n\n        quote {\n            $deserialization_of_struct_members\n\n            Self { $struct_members }\n        }\n    } else if params.len() == 1 {\n        let param_name = params[0].0;\n        quote {\n            Self { $param_name: $crate::serialization::Deserialize::stream_deserialize(reader) }\n        }\n    } else {\n        quote {\n            Self {}\n        }\n    };\n\n    quote {\n        impl$generics_declarations $crate::serialization::Deserialize for $typ\n            $where_deserialize_clause\n        {\n            let N: u32 = $right_hand_side_of_definition_of_n;\n\n            fn deserialize(fields: [Field; Self::N]) -> Self {\n                let mut reader = $crate::reader::Reader::new(fields);\n                let result = Self::stream_deserialize(&mut reader);\n                reader.finish();\n                result\n            }\n\n            #[inline_always]\n            fn stream_deserialize<let K: u32>(reader: &mut $crate::reader::Reader<K>) -> Self {\n                $function_body\n            }\n        }\n    }\n}\n\n/// Generates a quoted expression that computes the total serialized length of function parameters.\n///\n/// # Parameters\n/// * `params` - An array of tuples where each tuple contains a quoted parameter name and its Type. The type needs\n///              to implement the Serialize trait.\n///\n/// # Returns\n/// A quoted expression that evaluates to:\n/// * `0` if there are no parameters\n/// * `(<type1 as Serialize>::N + <type2 as Serialize>::N + ...)` for one or more parameters\ncomptime fn get_params_len_quote(params: [(Quoted, Type)]) -> Quoted {\n    if params.len() == 0 {\n        quote { 0 }\n    } else {\n        let params_quote_without_parentheses = params\n            .map(|(_, param_type): (Quoted, Type)| {\n                quote {\n                    <$param_type as $crate::serialization::Serialize>::N\n                }\n            })\n            .join(quote {+});\n        quote { ($params_quote_without_parentheses) }\n    }\n}\n\ncomptime fn get_generics_declarations(s: TypeDefinition) -> Quoted {\n    let generics = s.generics();\n\n    if generics.len() > 0 {\n        let generics_declarations_items = generics\n            .map(|(name, maybe_integer_typ)| {\n                // The second item in the generics tuple is an Option of an integer type that is Some only if\n                // the generic is numeric.\n                if maybe_integer_typ.is_some() {\n                    // The generic is numeric, so we return a quote defined as e.g. \"let N: u32\"\n                    let integer_type = maybe_integer_typ.unwrap();\n                    quote {let $name: $integer_type}\n                } else {\n                    // The generic is not numeric, so we return a quote containing the name of the generic (e.g. \"T\")\n                    quote {$name}\n                }\n            })\n            .join(quote {,});\n        quote {<$generics_declarations_items>}\n    } else {\n        // The struct doesn't have any generics defined, so we just return an empty quote.\n        quote {}\n    }\n}\n\ncomptime fn get_where_trait_clause(s: TypeDefinition, trait_name: Quoted) -> Quoted {\n    let generics = s.generics();\n\n    // The second item in the generics tuple is an Option of an integer type that is Some only if the generic is\n    // numeric.\n    let non_numeric_generics =\n        generics.filter(|(_, maybe_integer_typ)| maybe_integer_typ.is_none());\n\n    if non_numeric_generics.len() > 0 {\n        let non_numeric_generics_declarations =\n            non_numeric_generics.map(|(name, _)| quote {$name: $trait_name}).join(quote {,});\n        quote {where $non_numeric_generics_declarations}\n    } else {\n        // There are no non-numeric generics, so we return an empty quote.\n        quote {}\n    }\n}\n"
+      "source": "use crate::{reader::Reader, writer::Writer};\n\n/// Trait for serializing Noir types into arrays of Fields.\n///\n/// An implementation of the Serialize trait has to follow Noir's intrinsic serialization (each member of a struct\n/// converted directly into one or more Fields without any packing or compression). This trait (and Deserialize) are\n/// typically used to communicate between Noir and TypeScript (via oracles and function arguments).\n///\n/// # On Following Noir's Intrinsic Serialization\n/// When calling a Noir function from TypeScript (TS), first the function arguments are serialized into an array\n/// of fields. This array is then included in the initial witness. Noir's intrinsic serialization is then used\n/// to deserialize the arguments from the witness. When the same Noir function is called from Noir this Serialize trait\n/// is used instead of the serialization in TS. For this reason we need to have a match between TS serialization,\n/// Noir's intrinsic serialization and the implementation of this trait. If there is a mismatch, the function calls\n/// fail with an arguments hash mismatch error message.\n///\n/// # Associated Constants\n/// * `N` - The length of the output Field array, known at compile time\n///\n/// # Example\n/// ```\n/// impl<let N: u32> Serialize for str<N> {\n///     let N: u32 = N;\n///\n///     fn serialize(self) -> [Field; Self::N] {\n///         let mut writer: Writer<Self::N> = Writer::new();\n///         self.stream_serialize(&mut writer);\n///         writer.finish()\n///     }\n///\n///     fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n///         let bytes = self.as_bytes();\n///         for i in 0..bytes.len() {\n///             writer.write(bytes[i] as Field);\n///         }\n///     }\n/// }\n/// ```\n#[derive_via(derive_serialize)]\npub trait Serialize {\n    let N: u32;\n\n    fn serialize(self) -> [Field; Self::N];\n\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>);\n}\n\n/// Generates a `Serialize` trait implementation for a struct type.\n///\n/// # Parameters\n/// - `s`: The struct type definition to generate the implementation for\n///\n/// # Returns\n/// A quoted code block containing the trait implementation\n///\n/// # Example\n/// For a struct defined as:\n/// ```\n/// struct Log<N> {\n///     fields: [Field; N],\n///     length: u32\n/// }\n/// ```\n///\n/// This function generates code equivalent to:\n/// ```\n/// impl<let N: u32> Serialize for Log<N> {\n///     let N: u32 = <[Field; N] as Serialize>::N + <u32 as Serialize>::N;\n///\n///     fn serialize(self) -> [Field; Self::N] {\n///         let mut writer: Writer<Self::N> = Writer::new();\n///         self.stream_serialize(&mut writer);\n///         writer.finish()\n///     }\n///\n///     #[inline_always]\n///     fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n///         Serialize::stream_serialize(self.fields, writer);\n///         Serialize::stream_serialize(self.length, writer);\n///     }\n/// }\n/// ```\npub comptime fn derive_serialize(s: TypeDefinition) -> Quoted {\n    let typ = s.as_type();\n    let nested_struct = typ.as_data_type().unwrap();\n\n    // We care only about the name and type so we drop the last item of the tuple\n    let params = nested_struct.0.fields(nested_struct.1).map(|(name, typ, _)| (name, typ));\n\n    // Generates the generic parameter declarations (to be placed after the `impl` keyword) and the `where` clause\n    // for the `Serialize` trait.\n    let generics_declarations = get_generics_declarations(s);\n    let where_serialize_clause = get_where_trait_clause(s, quote {Serialize});\n\n    let params_len_quote = get_params_len_quote(params);\n\n    let function_body = params\n        .map(|(name, _typ): (Quoted, Type)| {\n            quote {\n                $crate::serialization::Serialize::stream_serialize(self.$name, writer);\n            }\n        })\n        .join(quote {});\n\n    quote {\n        impl$generics_declarations $crate::serialization::Serialize for $typ\n            $where_serialize_clause\n        {\n            let N: u32 = $params_len_quote;\n\n\n            fn serialize(self) -> [Field; Self::N] {\n                let mut writer: $crate::writer::Writer<Self::N> = $crate::writer::Writer::new();\n                $crate::serialization::Serialize::stream_serialize(self, &mut writer);\n                writer.finish()\n            }\n\n\n            #[inline_always]\n             fn stream_serialize<let K: u32>(self, writer: &mut $crate::writer::Writer<K>) {\n                $function_body\n            }\n        }\n    }\n}\n\n/// Trait for deserializing Noir types from arrays of Fields.\n///\n/// An implementation of the Deserialize trait has to follow Noir's intrinsic serialization (each member of a struct\n/// converted directly into one or more Fields without any packing or compression). This trait is typically used when\n/// deserializing return values from function calls in Noir. Since the same function could be called from TypeScript\n/// (TS), in which case the TS deserialization would get used, we need to have a match between the 2.\n///\n/// # Associated Constants\n/// * `N` - The length of the input Field array, known at compile time\n///\n/// # Example\n/// ```\n/// impl<let M: u32> Deserialize for str<M> {\n///     let N: u32 = M;\n///\n///     fn deserialize(fields: [Field; Self::N]) -> Self {\n///         let mut reader = Reader::new(fields);\n///         let result = Self::stream_deserialize(&mut reader);\n///         reader.finish();\n///         result\n///     }\n///\n///     fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n///         let mut bytes = [0 as u8; M];\n///         for i in 0..M {\n///             bytes[i] = reader.read() as u8;\n///         }\n///         str::<M>::from(bytes)\n///     }\n/// }\n/// ```\n#[derive_via(derive_deserialize)]\npub trait Deserialize {\n    let N: u32;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self;\n\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self;\n}\n\n/// Generates a `Deserialize` trait implementation for a given struct `s`.\n///\n/// # Arguments\n/// * `s` - The struct type definition to generate the implementation for\n///\n/// # Returns\n/// A `Quoted` block containing the generated trait implementation\n///\n/// # Requirements\n/// Each struct member type must implement the `Deserialize` trait (it gets used in the generated code).\n///\n/// # Example\n/// For a struct like:\n/// ```\n/// struct MyStruct {\n///     x: AztecAddress,\n///     y: Field,\n/// }\n/// ```\n///\n/// This generates:\n/// ```\n/// impl Deserialize for MyStruct {\n///     let N: u32 = <AztecAddress as Deserialize>::N + <Field as Deserialize>::N;\n///\n///     fn deserialize(fields: [Field; Self::N]) -> Self {\n///         let mut reader = Reader::new(fields);\n///         let result = Self::stream_deserialize(&mut reader);\n///         reader.finish();\n///         result\n///     }\n///\n///     #[inline_always]\n///     fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n///         let x = <AztecAddress as Deserialize>::stream_deserialize(reader);\n///         let y = <Field as Deserialize>::stream_deserialize(reader);\n///         Self { x, y }\n///     }\n/// }\n/// ```\npub comptime fn derive_deserialize(s: TypeDefinition) -> Quoted {\n    let typ = s.as_type();\n    let nested_struct = typ.as_data_type().unwrap();\n    let params = nested_struct.0.fields(nested_struct.1);\n\n    // Generates the generic parameter declarations (to be placed after the `impl` keyword) and the `where` clause\n    // for the `Deserialize` trait.\n    let generics_declarations = get_generics_declarations(s);\n    let where_deserialize_clause = get_where_trait_clause(s, quote {Deserialize});\n\n    // The following will give us:\n    // <type_of_struct_member_1 as Deserialize>::N + <type_of_struct_member_2 as Deserialize>::N + ...\n    // (or 0 if the struct has no members)\n    let right_hand_side_of_definition_of_n = if params.len() > 0 {\n        params\n            .map(|(_, param_type, _): (Quoted, Type, Quoted)| {\n                quote {\n            <$param_type as $crate::serialization::Deserialize>::N\n        }\n            })\n            .join(quote {+})\n    } else {\n        quote {0}\n    };\n\n    // For structs containing a single member, we can enhance performance by directly deserializing the input array,\n    // bypassing the need for loop-based array construction. While this optimization yields significant benefits in\n    // Brillig where the loops are expected to not be optimized, it is not relevant in ACIR where the loops are\n    // expected to be optimized away.\n    let function_body = if params.len() > 1 {\n        // This generates deserialization code for each struct member and concatenates them together.\n        let deserialization_of_struct_members = params\n            .map(|(param_name, param_type, _): (Quoted, Type, Quoted)| {\n                quote {\n                    let $param_name = <$param_type as Deserialize>::stream_deserialize(reader);\n                }\n            })\n            .join(quote {});\n\n        // We join the struct member names with a comma to be used in the `Self { ... }` syntax\n        // This will give us e.g. `a, b, c` for a struct with three fields named `a`, `b`, and `c`.\n        let struct_members = params\n            .map(|(param_name, _, _): (Quoted, Type, Quoted)| quote { $param_name })\n            .join(quote {,});\n\n        quote {\n            $deserialization_of_struct_members\n\n            Self { $struct_members }\n        }\n    } else if params.len() == 1 {\n        let param_name = params[0].0;\n        quote {\n            Self { $param_name: $crate::serialization::Deserialize::stream_deserialize(reader) }\n        }\n    } else {\n        quote {\n            Self {}\n        }\n    };\n\n    quote {\n        impl$generics_declarations $crate::serialization::Deserialize for $typ\n            $where_deserialize_clause\n        {\n            let N: u32 = $right_hand_side_of_definition_of_n;\n\n            fn deserialize(fields: [Field; Self::N]) -> Self {\n                let mut reader = $crate::reader::Reader::new(fields);\n                let result = Self::stream_deserialize(&mut reader);\n                reader.finish();\n                result\n            }\n\n            #[inline_always]\n            fn stream_deserialize<let K: u32>(reader: &mut $crate::reader::Reader<K>) -> Self {\n                $function_body\n            }\n        }\n    }\n}\n\n/// Generates a quoted expression that computes the total serialized length of function parameters.\n///\n/// # Parameters\n/// * `params` - An array of tuples where each tuple contains a quoted parameter name and its Type. The type needs\n///              to implement the Serialize trait.\n///\n/// # Returns\n/// A quoted expression that evaluates to:\n/// * `0` if there are no parameters\n/// * `(<type1 as Serialize>::N + <type2 as Serialize>::N + ...)` for one or more parameters\ncomptime fn get_params_len_quote(params: [(Quoted, Type)]) -> Quoted {\n    if params.len() == 0 {\n        quote { 0 }\n    } else {\n        let params_quote_without_parentheses = params\n            .map(|(_, param_type): (Quoted, Type)| {\n                quote {\n                    <$param_type as $crate::serialization::Serialize>::N\n                }\n            })\n            .join(quote {+});\n        quote { ($params_quote_without_parentheses) }\n    }\n}\n\ncomptime fn get_generics_declarations(s: TypeDefinition) -> Quoted {\n    let generics = s.generics();\n\n    if generics.len() > 0 {\n        let generics_declarations_items = generics\n            .map(|(name, maybe_integer_typ)| {\n                // The second item in the generics tuple is an Option of an integer type that is Some only if\n                // the generic is numeric.\n                if maybe_integer_typ.is_some() {\n                    // The generic is numeric, so we return a quote defined as e.g. \"let N: u32\"\n                    let integer_type = maybe_integer_typ.unwrap();\n                    quote {let $name: $integer_type}\n                } else {\n                    // The generic is not numeric, so we return a quote containing the name of the generic (e.g. \"T\")\n                    quote {$name}\n                }\n            })\n            .join(quote {,});\n        quote {<$generics_declarations_items>}\n    } else {\n        // The struct doesn't have any generics defined, so we just return an empty quote.\n        quote {}\n    }\n}\n\ncomptime fn get_where_trait_clause(s: TypeDefinition, trait_name: Quoted) -> Quoted {\n    let generics = s.generics();\n\n    // The second item in the generics tuple is an Option of an integer type that is Some only if the generic is\n    // numeric.\n    let non_numeric_generics =\n        generics.filter(|(_, maybe_integer_typ)| maybe_integer_typ.is_none());\n\n    if non_numeric_generics.len() > 0 {\n        let non_numeric_generics_declarations =\n            non_numeric_generics.map(|(name, _)| quote {$name: $trait_name}).join(quote {,});\n        quote {where $non_numeric_generics_declarations}\n    } else {\n        // There are no non-numeric generics, so we return an empty quote.\n        quote {}\n    }\n}\n"
     },
     "245": {
       "function_locations": [
@@ -2923,7 +2923,7 @@
       "custom_attributes": [
         "abi_public"
       ],
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "is_unconstrained": true,
       "name": "public_dispatch"
     },
@@ -4922,10 +4922,10 @@
       "custom_attributes": [
         "abi_private"
       ],
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "is_unconstrained": false,
       "name": "publish_for_public_execution",
-      "verification_key": "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"
+      "verification_key": "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"
     },
     {
       "abi": {